Merge branch 'develop' into develop_update

Reviewed-on: #159
Reviewed-by: Robin Müller <muellerr@irs.uni-stuttgart.de>

.idea/cmake.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CMakeSharedSettings">
+    <configurations>
+      <configuration PROFILE_NAME="Debug Test" ENABLED="true" CONFIG_NAME="Debug" GENERATION_OPTIONS="-DFSFW_BUILD_TESTS=ON -DFSFW_OSAL=host" />
+    </configurations>
+  </component>
+</project>

CHANGELOG.md

@@ -8,16 +8,50 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v6.0.0]
+## Fixes
+
+- The `PusTmCreator` API only accepted 255 bytes of source data. It can now accept source
+  data with a size limited only by the size of `size_t`.
+- Important bugfix in CFDP PDU header format: The entity length field and the transaction sequence
+  number fields stored the actual length of the field instead of the length minus 1 like specified
+  in the CFDP standard.
+- PUS Health Service: Size check for set health command.
+  Perform operation completion for announce health command.
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/746
+- Linux OSAL `getUptime` fix: Check validity of `/proc/uptime` file before reading uptime.
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/745
+- Small tweak for version getter
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/744
+
+## Added
+
+- add CFDP subsystem ID
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/742
+- `PusTmZcWriter` now exposes API to set message counter field.
+
+## Changed
+
+- HK generation is now countdown based.
+- Bump ETL version to 20.35.14
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/748
+- Renamed `PCDU_2` subsystem ID to `POWER_SWITCH_IF`.
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/743
+- Add new `PowerSwitchIF::SWITCH_UNKNOWN` returnvalue.
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/743
+- Assert that `FixedArrayList` is larger than 0 at compile time.
+  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/740
+- Health functions are virtual now.
+
+# [v6.0.0] 2023-02-10
 
 ## Fixes
 
-- Bugfix in `Service11TelecommandScheduling` which allowed commands
-  time tagged in the past to be inserted.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/738
+- Mode Service: Add allowed subservice
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/739
 - `CService200ModeManagement`: Various bugfixes which lead to now execution complete being generated
   on mode announcements, duplicate mode reply generated on announce commands, and the mode read
   subservice not working properly.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/736
 - Memory leak fixes for the TCP/IP TMTC bridge.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/737
 - `Service9TimeManagement`: Fix the time dump at the `SET_TIME` subservice: Include clock timeval
@@ -26,16 +60,20 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - HAL MGM3100 Handler: Use axis specific gain/scaling factors. Previously,
   only the X scaling factor was used.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/724
-- Bugfix for RM3100 MGM sensors. Z value was previously calculated
-  with bytes of the X value.
+- HAL MGM3100 Handler: Z value was previously calculated with bytes of the X value.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/733
 - DHB `setNormalDatapoolEntriesInvalid`: The default implementation did not set the validity
   to false correctly because the `read` and `write` calls were missing.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/728
 - PUS TMTC creator module: Sequence flags were set to continuation segment (0b00) instead
   of the correct unsegmented flags (0b11) as specified in the standard.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/727
 - TC Scheduler Service 11: Add size and CRC check for contained TC.
+  Bug: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/issues/719
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/720
 - Only delete health table entry in `HealthHelper` destructor if
   health table was set.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/710/files
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/710
 - I2C Bugfixes: Do not keep iterator as member and fix some incorrect handling with the iterator.
   Also properly reset the reply size for successfull transfers and erroneous transfers.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/700
@@ -45,6 +83,36 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - `TcpTmTcServer.cpp`: The server was actually not able to handle
   CCSDS packets which were clumped together. This has been fixed now.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/673
+- `CServiceHealthCommanding`: Add announce all health info implementation
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/725
+- various fixes related to linux Unittests and memory leaks
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/715
+- small fix to allow teardown handling
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/713
+- fix compiler warning for fixed array list copy ctor
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/704
+- missing include
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/703
+- defaultconfig did not build anymore
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/702
+- hotfix
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/699
+- small fix for helper
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/698
+- missing retval conv
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/697
+- DHB Countdown Bug
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/693
+- doc corrections
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/687
+- better error printout
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/686
+- include correction
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/683
+- better warning for missing include paths
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/676
+- Service 11 regression
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/670
 
 ## Added
 
@@ -63,17 +131,36 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/709
 - Add new `UnsignedByteField` class
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660
+- publish documentation for development and master branch
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/681
+- Add Linux HAL options
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/663
+- Expand SerializeIF
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/656
+- PUS Service 11: Additional Safety Check
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/666
+- improvements for auto-formatter script
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/665
+- provide a weak print char impl
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/674
+
+## Removed
+
+- now that doc server is up, remove markdown files
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/688
+- remove bsp specific code
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/679
 
 ## Changes
 
 - `CService201HealthCommanding` renamed to `CServiceHealthCommanding`,
   service ID customizable now. `CServiceHealthCommanding` expects configuration struct
   `HealthServiceCfg` now
-  PR: https://egit.irs.uni-stuttgart.de/eive/fsfw/pulls/122
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/725
 - `AcceptsTelemetryIF`: `getReportReceptionQueue` is const now
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/712
 - Moved some container returnvalues to dedicated header and namespace
-  to they can be used without template specification.
+  so they can be used without template specification.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/707
 - Remove default secondary header argument for
   `uint16_t getTcSpacePacketIdFromApid(uint16_t apid, bool secondaryHeaderFlag)` and
@@ -103,18 +190,41 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - `DeviceHandlerBase`: New signature of `handleDeviceTm` which expects
   a `const SerializeIF&` and additional helper variant which expects `const uint8_t*`
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/671
-- Move some generic `StorageManagerIF` implementations from `LocalPool` to
-  interface itself so it can be re-used more easily. Also add new
-  abstract function `bool hasDataAtId(store_address_t storeId) const`.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/685
 - Improvements for `AcceptsTelemetryIF` and `AcceptsTelecommandsIF`:
   - Make functions `const` where it makes sense
   - Add `const char* getName const` abstract function
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/684
-- Move some generic `StorageManagerIF` implementations from `LocalPool` to
-  interface itself so it can be re-used more easily. Also add new
-  abstract function `bool hasDataAtId(store_address_t storeId) const`.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/685
+- Generic TMTC Bridge Update
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/734
+- comment tweak to event parser can read everything
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/732
+- CMakeLists file updates
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/731
+- improve srv20 error messages
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/723
+- I2C Linux: remove duplicate printout
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/718
+- printout handling improvements
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/717
+- vec getter, reset for content
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/716
+- updates for source sequence counter
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/714
+- SP reader getPacketData is const now
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/708
+- refactoring of serial drivers for linux
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/705
+- Local Pool Update Remove Add Data Ignore Fault Argument
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/701
+- Switch to new documentation server
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/694
+- Windows Tweaks
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/691
+- Refactor Local Pool API
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/667
+- group MGM data in local pool vectors
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/664
+
 
 ## CFDP
 
@@ -134,17 +244,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
      implementation without an extra component
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/682
 
-## HAL
-
-- SPI: Cache the SPI device in the communication interface. Architecturally, this makes a
-  lot more sense because each ComIF should be responsible for one SPI bus.
-- SPI: Move the empty transfer to update the line polarity to separate function. This means
-  it is not automatically called when calling the setter function for SPI speed and mode.
-  The user should call this function after locking the CS mutex if multiple SPI devices with
-  differing speeds and modes are attached to one bus.
-- SPI: Getter functions for SPI speed and mode.
-
-# [v5.0.0] 25.07.2022
+# [v5.0.0] 2022-07-25
 
 ## Changes
 

CMakeLists.txt

@@ -13,7 +13,7 @@ list(APPEND CMAKE_MODULE_PATH
 # Version file handling  #
 # ##############################################################################
 
-set(FSFW_VERSION_IF_GIT_FAILS 5)
+set(FSFW_VERSION_IF_GIT_FAILS 6)
 set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
 set(FSFW_REVISION_IF_GIT_FAILS 0)
 
@@ -72,7 +72,7 @@ set(FSFW_ETL_LIB_MAJOR_VERSION
     20
     CACHE STRING "ETL library major version requirement")
 set(FSFW_ETL_LIB_VERSION
-    ${FSFW_ETL_LIB_MAJOR_VERSION}.28.0
+    ${FSFW_ETL_LIB_MAJOR_VERSION}.35.14
     CACHE STRING "ETL library exact version requirement")
 set(FSFW_ETL_LINK_TARGET etl::etl)
 

scripts/check_release.py

@@ -0,0 +1,110 @@
+#! /bin/python
+
+
+import argparse
+import json
+import urllib.request
+import re
+from pathlib import Path
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="List undocumented PRs"
+    )
+    parser.add_argument("-v", "--version", type=str, required=True)
+    args = parser.parse_args()
+    
+    match = re.search("([0-9]+\.[0-9]+\.[0-9]+)", args.version)
+    
+    if not match:
+        print("invalid version")
+        exit(1)
+    
+    version = "v" + match.group(1)
+    
+    print("looking for milestone for " + version + " ...")
+    
+    
+    with urllib.request.urlopen("https://egit.irs.uni-stuttgart.de/api/v1/repos/fsfw/fsfw/milestones?name=" + version) as milestone_json:
+        milestones = json.load(milestone_json)
+        if (len(milestones) == 0):
+            print("did not find any milestone")
+            exit(1)
+        if (len(milestones) > 1):
+            print("found multiple milestons")
+        milestone_title = milestones[0]['title']
+        milestone = str(milestones[0]['id'])
+        print("Using Milestone \""+ milestone_title + "\" with id " + milestone)
+    
+    milestone_prs = []
+    
+    page = 1
+    last_count = 1;
+    while last_count != 0:
+        with urllib.request.urlopen("https://egit.irs.uni-stuttgart.de/api/v1/repos/fsfw/fsfw/pulls?state=closed&milestone=" + str(milestone) + "&limit=100&page=" + str(page)) as pull_requests_json:
+            pull_requests = json.load(pull_requests_json)
+            for pr in pull_requests:
+                milestone_prs.append({'number': str(pr['number']), 'title' : pr['title']})
+            page += 1
+            last_count = len(pull_requests)
+    
+    print("Found " + str(len(milestone_prs)) + " closed PRs in Milestone")
+    
+    print("looking for CHANGELOG.md ...")
+    
+    path = Path(".")
+    
+    files = list(path.glob("CHANGELOG.md"))
+    
+    if (len(files) != 1):
+        files = list(path.glob("../CHANGELOG.md"))
+        
+    if (len(files) != 1):
+        print("did not find CHANGELOG.md. Run script in either root directory or scripts subfolder.")
+        exit(1)
+        
+    print("Scanning CHANGELOG.md ...")
+    
+    changelog_prs = []
+    
+    with open(files[0]) as changelog:
+        line = changelog.readline()
+        while (line):
+            #print("line: " + line)
+            match = re.search("\#.+(v[0-9]+\.[0-9]+\.[0-9]+)", line)
+            if (match):
+                if match.group(1) == version:
+                    #print("found version")
+                    line = changelog.readline()
+                    continue
+                else:
+                    #print("done with " + match.group(1))
+                    break
+            
+            match = re.search("PR: https://egit\.irs\.uni-stuttgart\.de/fsfw/fsfw/pulls/([0-9]+)", line)
+            if match:
+                changelog_prs.append(match.group(1))
+                
+            line = changelog.readline()
+    
+    print("Found " + str(len(changelog_prs)) + " PRs in CHANGELOG.md")
+    
+    print("")
+    
+    copy_array = changelog_prs.copy()
+    print("PRs in CHANGELOG.md that are not in Milestone:")
+    for pr in milestone_prs:
+        if pr['number'] in copy_array:
+            copy_array.remove(pr['number'])
+    for pr in copy_array:
+        print("https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/" + pr)
+
+    print("")
+
+    print("PRs in milestone that are not in CHANGELOG.md:")
+    
+    for pr in milestone_prs:
+        if pr['number'] not in changelog_prs:
+            print("- " + pr['title'] + "\n  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/" + pr['number'])
+
+main()

src/fsfw/action/ActionHelper.cpp

@@ -59,17 +59,24 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) { queueToUse = queue; }
 
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
                                     store_address_t dataAddress) {
+  bool hasAdditionalData = false;
   const uint8_t* dataPtr = nullptr;
   size_t size = 0;
-  ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-  if (result != returnvalue::OK) {
-    CommandMessage reply;
-    ActionMessage::setStepReply(&reply, actionId, 0, result);
-    queueToUse->sendMessage(commandedBy, &reply);
-    return;
+  ReturnValue_t result;
+  if (dataAddress != store_address_t::invalid()) {
+    hasAdditionalData = true;
+    ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+    if (result != returnvalue::OK) {
+      CommandMessage reply;
+      ActionMessage::setStepReply(&reply, actionId, 0, result);
+      queueToUse->sendMessage(commandedBy, &reply);
+      return;
+    }
   }
   result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-  ipcStore->deleteData(dataAddress);
+  if (hasAdditionalData) {
+    ipcStore->deleteData(dataAddress);
+  }
   if (result == HasActionsIF::EXECUTION_FINISHED) {
     CommandMessage reply;
     ActionMessage::setCompletionReply(&reply, actionId, true, result);

src/fsfw/cfdp.h

@@ -2,7 +2,6 @@
 #define FSFW_CFDP_H
 
 #include "cfdp/definitions.h"
-#include "cfdp/handler/CfdpHandler.h"
 #include "cfdp/handler/DestHandler.h"
 #include "cfdp/handler/FaultHandlerBase.h"
 #include "cfdp/helpers.h"

src/fsfw/cfdp/handler/CMakeLists.txt

@@ -1,3 +1,2 @@
-target_sources(
-  ${LIB_FSFW_NAME} PRIVATE SourceHandler.cpp DestHandler.cpp
-                           FaultHandlerBase.cpp UserBase.cpp CfdpHandler.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE SourceHandler.cpp DestHandler.cpp
+                                        FaultHandlerBase.cpp UserBase.cpp)

src/fsfw/cfdp/handler/CfdpHandler.cpp

@@ -1,134 +0,0 @@
-#include "CfdpHandler.h"
-
-#include "fsfw/cfdp/pdu/AckPduReader.h"
-#include "fsfw/cfdp/pdu/PduHeaderReader.h"
-#include "fsfw/globalfunctions/arrayprinter.h"
-#include "fsfw/ipc/QueueFactory.h"
-#include "fsfw/tmtcservices/TmTcMessage.h"
-
-using namespace returnvalue;
-using namespace cfdp;
-
-CfdpHandler::CfdpHandler(const FsfwHandlerParams& fsfwParams, const CfdpHandlerCfg& cfdpCfg)
-    : SystemObject(fsfwParams.objectId),
-      msgQueue(fsfwParams.msgQueue),
-      destHandler(
-          DestHandlerParams(LocalEntityCfg(cfdpCfg.id, cfdpCfg.indicCfg, cfdpCfg.faultHandler),
-                            cfdpCfg.userHandler, cfdpCfg.remoteCfgProvider, cfdpCfg.packetInfoList,
-                            cfdpCfg.lostSegmentsList),
-          FsfwParams(fsfwParams.packetDest, nullptr, this, fsfwParams.tcStore,
-                     fsfwParams.tmStore)) {
-  destHandler.setMsgQueue(msgQueue);
-}
-
-[[nodiscard]] const char* CfdpHandler::getName() const { return "CFDP Handler"; }
-
-[[nodiscard]] uint32_t CfdpHandler::getIdentifier() const {
-  return destHandler.getDestHandlerParams().cfg.localId.getValue();
-}
-
-[[nodiscard]] MessageQueueId_t CfdpHandler::getRequestQueue() const { return msgQueue.getId(); }
-
-ReturnValue_t CfdpHandler::initialize() {
-  ReturnValue_t result = destHandler.initialize();
-  if (result != OK) {
-    return result;
-  }
-  tcStore = destHandler.getTcStore();
-  tmStore = destHandler.getTmStore();
-
-  return SystemObject::initialize();
-}
-
-ReturnValue_t CfdpHandler::performOperation(uint8_t operationCode) {
-  // TODO: Receive TC packets and route them to source and dest handler, depending on which is
-  //       correct or more appropriate
-  ReturnValue_t status;
-  ReturnValue_t result = OK;
-  TmTcMessage tmtcMsg;
-  for (status = msgQueue.receiveMessage(&tmtcMsg); status == returnvalue::OK;
-       status = msgQueue.receiveMessage(&tmtcMsg)) {
-    result = handleCfdpPacket(tmtcMsg);
-    if (result != OK) {
-      status = result;
-    }
-  }
-  auto& fsmRes = destHandler.performStateMachine();
-  // TODO: Error handling?
-  while (fsmRes.callStatus == CallStatus::CALL_AGAIN) {
-    destHandler.performStateMachine();
-    // TODO: Error handling?
-  }
-  return status;
-}
-
-ReturnValue_t CfdpHandler::handleCfdpPacket(TmTcMessage& msg) {
-  auto accessorPair = tcStore->getData(msg.getStorageId());
-  if (accessorPair.first != OK) {
-    return accessorPair.first;
-  }
-  PduHeaderReader reader(accessorPair.second.data(), accessorPair.second.size());
-  ReturnValue_t result = reader.parseData();
-  if (result != returnvalue::OK) {
-    return INVALID_PDU_FORMAT;
-  }
-  // The CFDP distributor should have taken care of ensuring the destination ID is correct
-  PduType type = reader.getPduType();
-  // Only the destination handler can process these PDUs
-  if (type == PduType::FILE_DATA) {
-    // Disable auto-deletion of packet
-    accessorPair.second.release();
-    PacketInfo info(type, msg.getStorageId());
-    result = destHandler.passPacket(info);
-  } else {
-    // Route depending on PDU type and directive type if applicable. It retrieves directive type
-    // from the raw stream for better performance (with sanity and directive code check).
-    // The routing is based on section 4.5 of the CFDP standard which specifies the PDU forwarding
-    // procedure.
-
-    // PDU header only. Invalid supplied data. A directive packet should have a valid data field
-    // with at least one byte being the directive code
-    const uint8_t* pduDataField = reader.getPduDataField();
-    if (pduDataField == nullptr) {
-      return INVALID_PDU_FORMAT;
-    }
-    if (not FileDirectiveReader::checkFileDirective(pduDataField[0])) {
-      return INVALID_DIRECTIVE_FIELD;
-    }
-    auto directive = static_cast<FileDirective>(pduDataField[0]);
-
-    auto passToDestHandler = [&]() {
-      accessorPair.second.release();
-      PacketInfo info(type, msg.getStorageId(), directive);
-      result = destHandler.passPacket(info);
-    };
-    auto passToSourceHandler = [&]() {
-
-    };
-    if (directive == FileDirective::METADATA or directive == FileDirective::EOF_DIRECTIVE or
-        directive == FileDirective::PROMPT) {
-      // Section b) of 4.5.3: These PDUs should always be targeted towards the file receiver a.k.a.
-      // the destination handler
-      passToDestHandler();
-    } else if (directive == FileDirective::FINISH or directive == FileDirective::NAK or
-               directive == FileDirective::KEEP_ALIVE) {
-      // Section c) of 4.5.3: These PDUs should always be targeted towards the file sender a.k.a.
-      // the source handler
-      passToSourceHandler();
-    } else if (directive == FileDirective::ACK) {
-      // Section a): Recipient depends of the type of PDU that is being acknowledged. We can simply
-      // extract the PDU type from the raw stream. If it is an EOF PDU, this packet is passed to
-      // the source handler, for a Finished PDU, it is passed to the destination handler.
-      FileDirective ackedDirective;
-      if (not AckPduReader::checkAckedDirectiveField(pduDataField[1], ackedDirective)) {
-        return INVALID_ACK_DIRECTIVE_FIELDS;
-      }
-      if (ackedDirective == FileDirective::EOF_DIRECTIVE) {
-        passToSourceHandler();
-      } else if (ackedDirective == FileDirective::FINISH) {
-        passToDestHandler();
-      }
-    }
-  }
-  return result;
-}

src/fsfw/cfdp/handler/CfdpHandler.h

@@ -1,71 +0,0 @@
-#ifndef FSFW_EXAMPLE_HOSTED_CFDPHANDLER_H
-#define FSFW_EXAMPLE_HOSTED_CFDPHANDLER_H
-
-#include <utility>
-
-#include "fsfw/cfdp/handler/DestHandler.h"
-#include "fsfw/objectmanager/SystemObject.h"
-#include "fsfw/tasks/ExecutableObjectIF.h"
-#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
-#include "fsfw/tmtcservices/TmTcMessage.h"
-
-struct FsfwHandlerParams {
-  FsfwHandlerParams(object_id_t objectId, HasFileSystemIF& vfs, AcceptsTelemetryIF& packetDest,
-                    StorageManagerIF& tcStore, StorageManagerIF& tmStore, MessageQueueIF& msgQueue)
-      : objectId(objectId),
-        vfs(vfs),
-        packetDest(packetDest),
-        tcStore(tcStore),
-        tmStore(tmStore),
-        msgQueue(msgQueue) {}
-  object_id_t objectId{};
-  HasFileSystemIF& vfs;
-  AcceptsTelemetryIF& packetDest;
-  StorageManagerIF& tcStore;
-  StorageManagerIF& tmStore;
-  MessageQueueIF& msgQueue;
-};
-
-struct CfdpHandlerCfg {
-  CfdpHandlerCfg(cfdp::EntityId localId, cfdp::IndicationCfg indicationCfg,
-                 cfdp::UserBase& userHandler, cfdp::FaultHandlerBase& userFaultHandler,
-                 cfdp::PacketInfoListBase& packetInfo, cfdp::LostSegmentsListBase& lostSegmentsList,
-                 cfdp::RemoteConfigTableIF& remoteCfgProvider)
-      : id(std::move(localId)),
-        indicCfg(indicationCfg),
-        packetInfoList(packetInfo),
-        lostSegmentsList(lostSegmentsList),
-        remoteCfgProvider(remoteCfgProvider),
-        userHandler(userHandler),
-        faultHandler(userFaultHandler) {}
-
-  cfdp::EntityId id;
-  cfdp::IndicationCfg indicCfg;
-  cfdp::PacketInfoListBase& packetInfoList;
-  cfdp::LostSegmentsListBase& lostSegmentsList;
-  cfdp::RemoteConfigTableIF& remoteCfgProvider;
-  cfdp::UserBase& userHandler;
-  cfdp::FaultHandlerBase& faultHandler;
-};
-
-class CfdpHandler : public SystemObject, public ExecutableObjectIF, public AcceptsTelecommandsIF {
- public:
-  explicit CfdpHandler(const FsfwHandlerParams& fsfwParams, const CfdpHandlerCfg& cfdpCfg);
-
-  [[nodiscard]] const char* getName() const override;
-  [[nodiscard]] uint32_t getIdentifier() const override;
-  [[nodiscard]] MessageQueueId_t getRequestQueue() const override;
-
-  ReturnValue_t initialize() override;
-  ReturnValue_t performOperation(uint8_t operationCode) override;
-
- private:
-  MessageQueueIF& msgQueue;
-  cfdp::DestHandler destHandler;
-  StorageManagerIF* tcStore = nullptr;
-  StorageManagerIF* tmStore = nullptr;
-
-  ReturnValue_t handleCfdpPacket(TmTcMessage& msg);
-};
-
-#endif  // FSFW_EXAMPLE_HOSTED_CFDPHANDLER_H

src/fsfw/cfdp/pdu/HeaderCreator.cpp

@@ -24,8 +24,8 @@ ReturnValue_t HeaderCreator::serialize(uint8_t **buffer, size_t *size, size_t ma
   *buffer += 1;
   **buffer = pduDataFieldLen & 0x00ff;
   *buffer += 1;
-  **buffer = segmentationCtrl << 7 | pduConf.sourceId.getWidth() << 4 | segmentMetadataFlag << 3 |
-             pduConf.seqNum.getWidth();
+  **buffer = segmentationCtrl << 7 | ((pduConf.sourceId.getWidth() - 1) << 4) |
+             segmentMetadataFlag << 3 | (pduConf.seqNum.getWidth() - 1);
   *buffer += 1;
   *size += 4;
   ReturnValue_t result = pduConf.sourceId.serialize(buffer, size, maxSize, streamEndianness);

src/fsfw/cfdp/pdu/HeaderReader.cpp

@@ -78,11 +78,11 @@ cfdp::SegmentationControl PduHeaderReader::getSegmentationControl() const {
 }
 
 cfdp::WidthInBytes PduHeaderReader::getLenEntityIds() const {
-  return static_cast<cfdp::WidthInBytes>((pointers.fixedHeader->fourthByte >> 4) & 0x07);
+  return static_cast<cfdp::WidthInBytes>(((pointers.fixedHeader->fourthByte >> 4) & 0b111) + 1);
 }
 
 cfdp::WidthInBytes PduHeaderReader::getLenSeqNum() const {
-  return static_cast<cfdp::WidthInBytes>(pointers.fixedHeader->fourthByte & 0x07);
+  return static_cast<cfdp::WidthInBytes>((pointers.fixedHeader->fourthByte & 0b111) + 1);
 }
 
 cfdp::SegmentMetadataFlag PduHeaderReader::getSegmentMetadataFlag() const {

src/fsfw/controller/ControllerBase.cpp

@@ -58,7 +58,7 @@ void ControllerBase::handleQueue() {
 
 void ControllerBase::startTransition(Mode_t mode_, Submode_t submode_) {
   changeHK(this->mode, this->submode, false);
-  triggerEvent(CHANGING_MODE, mode, submode);
+  triggerEvent(CHANGING_MODE, mode_, submode_);
   mode = mode_;
   submode = submode_;
   modeHelper.modeChanged(mode, submode);

src/fsfw/coordinates/Sgp4Propagator.cpp

@@ -166,9 +166,9 @@ ReturnValue_t Sgp4Propagator::propagate(double* position, double* velocity, time
   timeval timeSinceEpoch = time - epoch;
   double minutesSinceEpoch = timeSinceEpoch.tv_sec / 60. + timeSinceEpoch.tv_usec / 60000000.;
 
-  double yearsSinceEpoch = minutesSinceEpoch / 60 / 24 / 365;
+  double monthsSinceEpoch = minutesSinceEpoch / 60 / 24 / 30;
 
-  if ((yearsSinceEpoch > 1) || (yearsSinceEpoch < -1)) {
+  if ((monthsSinceEpoch > 1) || (monthsSinceEpoch < -1)) {
     return TLE_TOO_OLD;
   }
 

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -70,8 +70,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
   return returnvalue::OK;
 }
 
-ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(uint8_t nonDiagInvlFactor) {
-  setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
+ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation() {
   return initializeHousekeepingPoolEntriesOnce();
 }
 
@@ -506,9 +505,9 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
       float newCollIntvl = 0;
       HousekeepingMessage::getCollectionIntervalModificationCommand(message, &newCollIntvl);
       if (command == HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
-        result = changeCollectionInterval(sid, newCollIntvl, true);
+        result = changeCollectionInterval(sid, newCollIntvl);
       } else {
-        result = changeCollectionInterval(sid, newCollIntvl, false);
+        result = changeCollectionInterval(sid, newCollIntvl);
       }
       break;
     }
@@ -661,10 +660,6 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(HousekeepingPacke
   return hkPacket.serialize(&dataPtr, serializedSize, maxSize, SerializeIF::Endianness::MACHINE);
 }
 
-void LocalDataPoolManager::setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor) {
-  this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
-}
-
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
   sid_t sid = receiver.dataId.sid;
   LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
@@ -718,15 +713,15 @@ ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid, bool ena
 
   if ((LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and enable) or
       (not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and not enable)) {
-    return REPORTING_STATUS_UNCHANGED;
+    return returnvalue::OK;
   }
 
   LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enable);
   return returnvalue::OK;
 }
 
-ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid, float newCollectionInterval,
-                                                             bool isDiagnostics) {
+ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
+                                                             float newCollectionInterval) {
   LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
   if (dataSet == nullptr) {
     printWarningOrError(sif::OutputTypes::OUT_WARNING, "changeCollectionInterval",
@@ -734,11 +729,6 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid, float ne
     return DATASET_NOT_FOUND;
   }
 
-  bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
-  if ((targetIsDiagnostics and not isDiagnostics) or (not targetIsDiagnostics and isDiagnostics)) {
-    return WRONG_HK_PACKET_TYPE;
-  }
-
   PeriodicHousekeepingHelper* periodicHelper =
       LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
 

src/fsfw/datapoollocal/LocalDataPoolManager.h

@@ -102,7 +102,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
    * @param nonDiagInvlFactor
    * @return
    */
-  ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
+  ReturnValue_t initializeAfterTaskCreation();
 
   /**
    * @brief   This should be called in the periodic handler of the owner.
@@ -152,17 +152,6 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
                                                   MessageQueueId_t targetQueueId,
                                                   bool generateSnapshot) override;
 
-  /**
-   * Non-Diagnostics packets usually have a lower minimum sampling frequency
-   * than diagnostic packets.
-   * A factor can be specified to determine the minimum sampling frequency
-   * for non-diagnostic packets. The minimum sampling frequency of the
-   * diagnostics packets,which is usually jusst the period of the
-   * performOperation calls, is multiplied with that factor.
-   * @param factor
-   */
-  void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
-
   /**
    * @brief   The manager is also able to handle housekeeping messages.
    * @details
@@ -185,6 +174,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   ReturnValue_t generateHousekeepingPacket(sid_t sid, LocalPoolDataSetBase* dataSet,
                                            bool forDownlink,
                                            MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
+  ReturnValue_t changeCollectionInterval(sid_t sid, float newCollectionInterval);
 
   HasLocalDataPoolIF* getOwner();
 
@@ -348,8 +338,6 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
 
   void performPeriodicHkGeneration(HkReceiver& hkReceiver);
   ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable, bool isDiagnostics);
-  ReturnValue_t changeCollectionInterval(sid_t sid, float newCollectionInterval,
-                                         bool isDiagnostics);
   ReturnValue_t generateSetStructurePacket(sid_t sid, bool isDiagnostics);
 
   void handleHkUpdateResetListInsertion(DataType dataType, DataId dataId);

src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp

@@ -250,9 +250,8 @@ void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
 bool LocalPoolDataSetBase::getReportingEnabled() const { return reportingEnabled; }
 
 void LocalPoolDataSetBase::initializePeriodicHelper(float collectionInterval,
-                                                    dur_millis_t minimumPeriodicInterval,
-                                                    uint8_t nonDiagIntervalFactor) {
-  periodicHelper->initialize(collectionInterval, minimumPeriodicInterval, nonDiagIntervalFactor);
+                                                    dur_millis_t minimumPeriodicInterval) {
+  periodicHelper->initialize(collectionInterval, minimumPeriodicInterval);
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) { this->changed = changed; }

src/fsfw/datapoollocal/LocalPoolDataSetBase.h

@@ -191,8 +191,7 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    */
   bool reportingEnabled = false;
 
-  void initializePeriodicHelper(float collectionInterval, dur_millis_t minimumPeriodicInterval,
-                                uint8_t nonDiagIntervalFactor = 5);
+  void initializePeriodicHelper(float collectionInterval, dur_millis_t minimumPeriodicInterval);
 
   /**
    * If the valid state of a dataset is always relevant to the whole

src/fsfw/datapoollocal/internal/LocalPoolDataSetAttorney.h

@@ -12,10 +12,8 @@ class LocalPoolDataSetAttorney {
   static bool isDiagnostics(LocalPoolDataSetBase& set) { return set.isDiagnostics(); }
 
   static void initializePeriodicHelper(LocalPoolDataSetBase& set, float collectionInterval,
-                                       uint32_t minimumPeriodicIntervalMs,
-                                       uint8_t nonDiagIntervalFactor = 5) {
-    set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs,
-                                 nonDiagIntervalFactor);
+                                       uint32_t minimumPeriodicIntervalMs) {
+    set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs);
   }
 
   static void setReportingEnabled(LocalPoolDataSetBase& set, bool enabled) {

src/fsfw/devicehandlers/DeviceCommunicationIF.h

@@ -49,6 +49,7 @@ class DeviceCommunicationIF {
   // is this needed if there is no open/close call?
   static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
   static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
+  static constexpr ReturnValue_t BUSY = MAKE_RETURN_CODE(0x07);
 
   virtual ~DeviceCommunicationIF() {}
 

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -565,6 +565,9 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
    */
   if (newMode == MODE_ON and continueToNormal) {
     continueToNormal = false;
+    // TODO: Check whether the following two lines are okay to do so.
+    transitionSourceMode = MODE_ON;
+    transitionSourceSubMode = newSubmode;
     mode = _MODE_TO_NORMAL;
     return;
   }

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -257,8 +257,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   Mode_t getTransitionSourceMode() const;
   Submode_t getTransitionSourceSubMode() const;
   virtual void getMode(Mode_t *mode, Submode_t *submode);
-  HealthState getHealth();
-  ReturnValue_t setHealth(HealthState health);
+  virtual HealthState getHealth() override;
+  virtual ReturnValue_t setHealth(HealthState health) override;
   virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
                                      ParameterWrapper *parameterWrapper,
                                      const ParameterWrapper *newValues,

src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp

@@ -10,8 +10,9 @@
 
 object_id_t DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
 
-DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent)
-    : FailureIsolationBase(owner, parent),
+DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent,
+                                                             uint8_t eventQueueDepth)
+    : FailureIsolationBase(owner, parent, eventQueueDepth),
       strangeReplyCount(DEFAULT_MAX_STRANGE_REPLIES, DEFAULT_STRANGE_REPLIES_TIME_MS,
                         parameterDomainBase++),
       missedReplyCount(DEFAULT_MAX_MISSED_REPLY_COUNT, DEFAULT_MISSED_REPLY_TIME_MS,

src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.h

@@ -13,7 +13,8 @@ class DeviceHandlerFailureIsolation : public FailureIsolationBase {
   friend class Heater;
 
  public:
-  DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent);
+  DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent,
+                                uint8_t eventQueueDepth = 10);
   ~DeviceHandlerFailureIsolation();
   ReturnValue_t initialize();
   void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);

src/fsfw/devicehandlers/HealthDevice.cpp

@@ -29,11 +29,10 @@ ReturnValue_t HealthDevice::initialize() {
   if (result != returnvalue::OK) {
     return result;
   }
-  if (parentQueue != 0) {
+  if (parentQueue != MessageQueueIF::NO_QUEUE) {
     return healthHelper.initialize(parentQueue);
-  } else {
-    return healthHelper.initialize();
   }
+  return healthHelper.initialize();
 }
 
 MessageQueueId_t HealthDevice::getCommandQueue() const { return commandQueue->getId(); }

src/fsfw/devicehandlers/HealthDevice.h

@@ -29,10 +29,8 @@ class HealthDevice : public SystemObject, public ExecutableObjectIF, public HasH
  protected:
   HealthState lastHealth;
 
-  MessageQueueId_t parentQueue;
+  MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
   MessageQueueIF* commandQueue;
-
- public:
   HealthHelper healthHelper;
 };
 

src/fsfw/events/EventManager.cpp

@@ -15,12 +15,12 @@ const LocalPool::LocalPoolConfig EventManager::poolConfig = {
     {fsfwconfig::FSFW_EVENTMGMT_EVENTIDMATCHERS, sizeof(EventIdRangeMatcher)},
     {fsfwconfig::FSFW_EVENTMGMR_RANGEMATCHERS, sizeof(ReporterRangeMatcher)}};
 
-EventManager::EventManager(object_id_t setObjectId)
+EventManager::EventManager(object_id_t setObjectId, uint32_t eventQueueDepth)
     : SystemObject(setObjectId), factoryBackend(0, poolConfig, false, true) {
   mutex = MutexFactory::instance()->createMutex();
   auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
   eventReportQueue = QueueFactory::instance()->createMessageQueue(
-      MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
+      eventQueueDepth, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
 }
 
 EventManager::~EventManager() {
@@ -55,8 +55,9 @@ void EventManager::notifyListeners(EventMessage* message) {
       if (result != returnvalue::OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << std::hex << "EventManager::notifyListeners: MSG to 0x" << std::setfill('0')
-                   << std::setw(8) << listener.first << " failed with result 0x" << std::setw(4)
-                   << result << std::setfill(' ') << std::endl;
+                   << std::setw(8) << listener.first << " for event 0x" << std::setw(4)
+                   << message->getEventId() << " failed with result 0x" << std::setw(4) << result
+                   << std::setfill(' ') << std::endl;
 #else
         sif::printError("Sending message to listener 0x%08x failed with result %04x\n",
                         listener.first, result);

src/fsfw/events/EventManager.h

@@ -21,9 +21,9 @@ extern const char* translateEvents(Event event);
 
 class EventManager : public EventManagerIF, public ExecutableObjectIF, public SystemObject {
  public:
-  static const uint16_t MAX_EVENTS_PER_CYCLE = 80;
+  static const uint16_t DEFAULT_MAX_EVENTS_PER_CYCLE = 80;
 
-  EventManager(object_id_t setObjectId);
+  EventManager(object_id_t setObjectId, uint32_t eventQueueDepth);
   virtual ~EventManager();
 
   void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);

src/fsfw/events/fwSubsystemIdRanges.h

@@ -10,7 +10,7 @@ enum : uint8_t {
   CDH = 28,
   TCS_1 = 59,
   PCDU_1 = 42,
-  PCDU_2 = 43,
+  POWER_SWITCH_IF = 43,
   HEATER = 50,
   T_SENSORS = 52,
   FDIR = 70,

src/fsfw/fdir/FaultCounter.cpp

@@ -68,7 +68,7 @@ ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint8_t uniqueId,
       parameterWrapper->set(faultCount);
       break;
     case ParameterIds::TIMEOUT:
-      parameterWrapper->set(timer.timeout);
+      parameterWrapper->set(timer.getTimeoutMs());
       break;
     default:
       return INVALID_IDENTIFIER_ID;

src/fsfw/globalfunctions/DleParser.h

@@ -18,8 +18,11 @@
  */
 class DleParser {
  public:
+  //! [EXPORT] : [SKIP]
   static constexpr ReturnValue_t NO_PACKET_FOUND = returnvalue::makeCode(1, 1);
+  //! [EXPORT] : [SKIP]
   static constexpr ReturnValue_t POSSIBLE_PACKET_LOSS = returnvalue::makeCode(1, 2);
+
   using BufPair = std::pair<uint8_t*, size_t>;
 
   enum class ContextType { NONE, PACKET_FOUND, ERROR };

src/fsfw/globalfunctions/math/VectorOperations.h

@@ -53,8 +53,9 @@ class VectorOperations {
     mulScalar(vector, 1 / norm(vector, size), normalizedVector, size);
   }
 
-  static T maxAbsValue(const T *vector, uint8_t size, uint8_t *index = 0) {
-    T max = -1;
+  static T maxAbsValue(const T *vector, uint8_t size, uint8_t *index = nullptr) {
+    T max = vector[size - 1];
+    uint8_t foundIndex = size - 1;
 
     for (; size > 0; size--) {
       T abs = vector[size - 1];
@@ -64,24 +65,35 @@ class VectorOperations {
       if (abs > max) {
         max = abs;
         if (index != 0) {
-          *index = size - 1;
+          foundIndex = size - 1;
         }
       }
     }
+
+    if (index != nullptr) {
+      *index = foundIndex;
+    }
+
     return max;
   }
 
-  static T maxValue(const T *vector, uint8_t size, uint8_t *index = 0) {
-    T max = -1;
+  static T maxValue(const T *vector, uint8_t size, uint8_t *index = nullptr) {
+    T max = vector[size - 1];
+    uint8_t foundIndex = size - 1;
 
     for (; size > 0; size--) {
       if (vector[size - 1] > max) {
         max = vector[size - 1];
         if (index != 0) {
-          *index = size - 1;
+          foundIndex = size - 1;
         }
       }
     }
+
+    if (index != nullptr) {
+      *index = foundIndex;
+    }
+
     return max;
   }
 

src/fsfw/housekeeping/PeriodicHousekeepingHelper.cpp

@@ -3,85 +3,37 @@
 #include <cmath>
 
 #include "fsfw/datapoollocal/LocalPoolDataSetBase.h"
+#include "fsfw/serviceinterface.h"
 
 PeriodicHousekeepingHelper::PeriodicHousekeepingHelper(LocalPoolDataSetBase* owner)
     : owner(owner) {}
 
 void PeriodicHousekeepingHelper::initialize(float collectionInterval,
-                                            dur_millis_t minimumPeriodicInterval,
-                                            uint8_t nonDiagIntervalFactor) {
+                                            dur_millis_t minimumPeriodicInterval) {
   this->minimumPeriodicInterval = minimumPeriodicInterval;
-  this->nonDiagIntervalFactor = nonDiagIntervalFactor;
-  collectionIntervalTicks = intervalSecondsToIntervalTicks(collectionInterval);
-  /* This will cause a checkOpNecessary call to be true immediately. I think it's okay
-      if a HK packet is generated immediately instead of waiting one generation cycle. */
-  internalTickCounter = collectionIntervalTicks;
+  changeCollectionInterval(collectionInterval);
 }
 
 float PeriodicHousekeepingHelper::getCollectionIntervalInSeconds() const {
-  return intervalTicksToSeconds(collectionIntervalTicks);
+  return collectionInterval;
 }
 
 bool PeriodicHousekeepingHelper::checkOpNecessary() {
-  if (internalTickCounter >= collectionIntervalTicks) {
-    internalTickCounter = 1;
+  if (hkGenerationCd.hasTimedOut()) {
+    hkGenerationCd.resetTimer();
     return true;
   }
-  internalTickCounter++;
   return false;
 }
 
-uint32_t PeriodicHousekeepingHelper::intervalSecondsToIntervalTicks(
-    float collectionIntervalSeconds) {
-  if (owner == nullptr) {
-    return 0;
-  }
-  bool isDiagnostics = owner->isDiagnostics();
-
-  /* Avoid division by zero */
-  if (minimumPeriodicInterval == 0) {
-    if (isDiagnostics) {
-      /* Perform operation each cycle */
-      return 1;
-    } else {
-      return nonDiagIntervalFactor;
-    }
-  } else {
-    dur_millis_t intervalInMs = collectionIntervalSeconds * 1000;
-    uint32_t divisor = minimumPeriodicInterval;
-    if (not isDiagnostics) {
-      /* We need to multiply the divisor because non-diagnostics only
-      allow a multiple of the minimum periodic interval */
-      divisor *= nonDiagIntervalFactor;
-    }
-    uint32_t ticks = std::ceil(static_cast<float>(intervalInMs) / divisor);
-    if (not isDiagnostics) {
-      /* Now we need to multiply the calculated ticks with the factor as as well
-      because the minimum tick count to generate a non-diagnostic is the factor itself.
-
-      Example calculation for non-diagnostic with
-      0.4 second interval and 0.2 second task interval.
-      Resultant tick count of 5 is equal to operation each second.
-
-      Examle calculation for non-diagnostic with  2.0 second interval and 0.2 second
-      task interval.
-      Resultant tick count of 10 is equal to operatin every 2 seconds.
-
-      Example calculation for diagnostic with 0.4 second interval and 0.3
-      second task interval. Resulting tick count of 2 is equal to operation
-      every 0.6 seconds. */
-      ticks *= nonDiagIntervalFactor;
-    }
-    return ticks;
-  }
-}
-
-float PeriodicHousekeepingHelper::intervalTicksToSeconds(uint32_t collectionInterval) const {
-  /* Number of ticks times the minimum interval is in milliseconds, so we divide by 1000 to get
-  the value in seconds */
-  return static_cast<float>(collectionInterval * minimumPeriodicInterval / 1000.0);
-}
-
 void PeriodicHousekeepingHelper::changeCollectionInterval(float newIntervalSeconds) {
-  collectionIntervalTicks = intervalSecondsToIntervalTicks(newIntervalSeconds);
+  uint32_t intervalMs = newIntervalSeconds * 1000;
+  if (newIntervalSeconds <= 0) {
+    intervalMs = minimumPeriodicInterval;
+    newIntervalSeconds = static_cast<float>(minimumPeriodicInterval) / 1000.0;
+  }
+  collectionInterval = newIntervalSeconds;
+  hkGenerationCd.setTimeout(intervalMs);
+  // We want an immediate HK packet at the start, so time out the generation CD immediately.
+  hkGenerationCd.timeOut();
 }

src/fsfw/housekeeping/PeriodicHousekeepingHelper.h

@@ -4,6 +4,7 @@
 #include <cstdint>
 
 #include "fsfw/timemanager/Clock.h"
+#include "fsfw/timemanager/Countdown.h"
 
 class LocalPoolDataSetBase;
 
@@ -11,8 +12,7 @@ class PeriodicHousekeepingHelper {
  public:
   PeriodicHousekeepingHelper(LocalPoolDataSetBase* owner);
 
-  void initialize(float collectionInterval, dur_millis_t minimumPeriodicInterval,
-                  uint8_t nonDiagIntervalFactor);
+  void initialize(float collectionInterval, dur_millis_t minimumPeriodicInterval);
 
   void changeCollectionInterval(float newInterval);
   float getCollectionIntervalInSeconds() const;
@@ -20,14 +20,10 @@ class PeriodicHousekeepingHelper {
 
  private:
   LocalPoolDataSetBase* owner = nullptr;
-  uint8_t nonDiagIntervalFactor = 0;
-
-  uint32_t intervalSecondsToIntervalTicks(float collectionIntervalSeconds);
-  float intervalTicksToSeconds(uint32_t collectionInterval) const;
+  Countdown hkGenerationCd;
+  float collectionInterval = 0.0;
 
   dur_millis_t minimumPeriodicInterval = 0;
-  uint32_t internalTickCounter = 1;
-  uint32_t collectionIntervalTicks = 0;
 };
 
 #endif /* FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_ */

src/fsfw/internalerror/InternalErrorReporter.cpp

@@ -5,9 +5,12 @@
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth)
+InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth,
+                                             bool enableSetByDefault, float generationFrequency)
     : SystemObject(setObjectId),
       poolManager(this, commandQueue),
+      enableSetByDefault(enableSetByDefault),
+      generationFrequency(generationFrequency),
       internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
       internalErrorDataset(this) {
   commandQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
@@ -134,9 +137,8 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(localpool::DataPool
   localDataPoolMap.emplace(errorPoolIds::TM_HITS, &tmHitsEntry);
   localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS, &queueHitsEntry);
   localDataPoolMap.emplace(errorPoolIds::STORE_HITS, &storeHitsEntry);
-  poolManager.subscribeForDiagPeriodicPacket(subdp::DiagnosticsHkPeriodicParams(
-      internalErrorSid, false,
-      static_cast<float>(getPeriodicOperationFrequency()) / static_cast<float>(1000.0)));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(internalErrorSid, enableSetByDefault, generationFrequency));
   internalErrorDataset.setValidity(true, true);
   return returnvalue::OK;
 }

src/fsfw/internalerror/InternalErrorReporter.h

@@ -21,7 +21,8 @@ class InternalErrorReporter : public SystemObject,
                               public InternalErrorReporterIF,
                               public HasLocalDataPoolIF {
  public:
-  InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth = 5);
+  InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth,
+                        bool enableSetByDefault, float generationFrequency);
 
   /**
    * Enable diagnostic printout. Please note that this feature will
@@ -63,6 +64,8 @@ class InternalErrorReporter : public SystemObject,
   MutexIF* mutex = nullptr;
   MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
   uint32_t timeoutMs = 20;
+  bool enableSetByDefault;
+  float generationFrequency;
 
   sid_t internalErrorSid;
   InternalErrorDataset internalErrorDataset;

src/fsfw/ipc/MutexGuard.h

@@ -7,14 +7,17 @@
 class MutexGuard {
  public:
   MutexGuard(MutexIF* mutex, MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::BLOCKING,
-             uint32_t timeoutMs = 0)
+             uint32_t timeoutMs = 0, const char* context = nullptr)
       : internalMutex(mutex) {
+    if (context == nullptr) {
+      context = "unknown";
+    }
     if (mutex == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "MutexGuard: Passed mutex is invalid!" << std::endl;
+      sif::error << "MutexGuard::" << context << ": Passed mutex is invalid!" << std::endl;
 #else
-      sif::printError("MutexGuard: Passed mutex is invalid!\n");
+      sif::printError("MutexGuard::%s: Passed mutex is invalid!\n", context);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
       return;
@@ -23,11 +26,11 @@ class MutexGuard {
 #if FSFW_VERBOSE_LEVEL >= 1
     if (result == MutexIF::MUTEX_TIMEOUT) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "MutexGuard: Lock of mutex failed with timeout of " << timeoutMs
-                 << " milliseconds!" << std::endl;
+      sif::error << "MutexGuard::" << context << ": Lock of mutex failed with timeout of "
+                 << timeoutMs << " milliseconds!" << std::endl;
 #else
-      sif::printError("MutexGuard: Lock of mutex failed with timeout of %lu milliseconds\n",
-                      timeoutMs);
+      sif::printError("MutexGuard::%s: Lock of mutex failed with timeout of %lu milliseconds\n",
+                      context, timeoutMs);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 
     } else if (result != returnvalue::OK) {

src/fsfw/osal/common/TcpTmTcBridge.cpp

@@ -16,9 +16,9 @@
 
 #endif
 
-TcpTmTcBridge::TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination, object_id_t tmStoreId,
-                             object_id_t tcStoreId)
-    : TmTcBridge("TCP TMTC Bridge", objectId, tcDestination, tmStoreId, tcStoreId) {
+TcpTmTcBridge::TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
+                             uint32_t msgQueueDepth, object_id_t tmStoreId, object_id_t tcStoreId)
+    : TmTcBridge("TCP TMTC Bridge", objectId, tcDestination, msgQueueDepth, tmStoreId, tcStoreId) {
   mutex = MutexFactory::instance()->createMutex();
   // Connection is always up, TM is requested by connecting to server and receiving packets
   registerCommConnect();

src/fsfw/osal/common/TcpTmTcBridge.h

@@ -38,7 +38,7 @@ class TcpTmTcBridge : public TmTcBridge {
    * @param tmStoreId TM store object ID. It is recommended to the default object ID
    * @param tcStoreId TC store object ID. It is recommended to the default object ID
    */
-  TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
+  TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination, uint32_t msgQueueDepth,
                 object_id_t tmStoreId = objects::TM_STORE,
                 object_id_t tcStoreId = objects::TC_STORE);
   virtual ~TcpTmTcBridge();

src/fsfw/osal/common/UdpTmTcBridge.cpp

@@ -20,9 +20,9 @@
 const std::string UdpTmTcBridge::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
 
 UdpTmTcBridge::UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
-                             const std::string &udpServerPort_, object_id_t tmStoreId,
-                             object_id_t tcStoreId)
-    : TmTcBridge("UDP TMTC Bridge", objectId, tcDestination, tmStoreId, tcStoreId) {
+                             uint32_t msgQueueDepth, const std::string &udpServerPort_,
+                             object_id_t tmStoreId, object_id_t tcStoreId)
+    : TmTcBridge("UDP TMTC Bridge", objectId, tcDestination, msgQueueDepth, tmStoreId, tcStoreId) {
   if (udpServerPort_.empty()) {
     udpServerPort = DEFAULT_SERVER_PORT;
   } else {

src/fsfw/osal/common/UdpTmTcBridge.h

@@ -29,7 +29,7 @@ class UdpTmTcBridge : public TmTcBridge, public TcpIpBase {
   /* The ports chosen here should not be used by any other process. */
   static const std::string DEFAULT_SERVER_PORT;
 
-  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
+  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination, uint32_t msgQueueDepth,
                 const std::string& udpServerPort = "", object_id_t tmStoreId = objects::TM_STORE,
                 object_id_t tcStoreId = objects::TC_STORE);
   ~UdpTmTcBridge() override;

src/fsfw/osal/host/Clock.cpp

@@ -47,7 +47,32 @@ ReturnValue_t Clock::setClock(const timeval* time) {
   return returnvalue::OK;
 }
 
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
+ReturnValue_t Clock::getClockMonotonic(timeval* time) {
+#if defined(PLATFORM_WIN)
+  // TODO: Implement with std::chrono::steady_clock.. or in some other way. I am not even sure
+  // whether this is possible with steady_clock. The conversion we have to do here just to be
+  // generic is kind of awkward..
+  return returnvalue::FAILED;
+#elif defined(PLATFORM_UNIX)
+  timespec timeMonotonic;
+  int status = clock_gettime(CLOCK_MONOTONIC_RAW, &timeMonotonic);
+  if (status != 0) {
+    return returnvalue::FAILED;
+  }
+  time->tv_sec = timeMonotonic.tv_sec;
+  time->tv_usec = timeMonotonic.tv_nsec / 1000.0;
+  return returnvalue::OK;
+#else
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "Clock::getUptime: Not implemented for found OS!" << std::endl;
+#else
+  sif::printWarning("Clock::getUptime: Not implemented for found OS!\n");
+#endif
+  return returnvalue::FAILED;
+#endif
+}
+
+ReturnValue_t Clock::getClock(timeval* time) {
 #if defined(PLATFORM_WIN)
   auto now = std::chrono::system_clock::now();
   auto secondsChrono = std::chrono::time_point_cast<std::chrono::seconds>(now);
@@ -75,6 +100,8 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 #endif
 }
 
+ReturnValue_t Clock::getClock_timeval(timeval* time) { return Clock::getClock(time); }
+
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
   if (time == nullptr) {
     return returnvalue::FAILED;

src/fsfw/osal/host/TaskFactory.cpp

@@ -20,16 +20,18 @@ TaskFactory::~TaskFactory() = default;
 
 TaskFactory* TaskFactory::instance() { return TaskFactory::factoryInstance; }
 
-PeriodicTaskIF* TaskFactory::createPeriodicTask(
-    TaskName name_, TaskPriority taskPriority_, TaskStackSize stackSize_,
-    TaskPeriod periodInSeconds_, TaskDeadlineMissedFunction deadLineMissedFunction_) {
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_, TaskPriority taskPriority_,
+                                                TaskStackSize stackSize_,
+                                                TaskPeriod periodInSeconds_,
+                                                TaskDeadlineMissedFunction deadLineMissedFunction_,
+                                                void* args) {
   return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
                           deadLineMissedFunction_);
 }
 
 FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(
     TaskName name_, TaskPriority taskPriority_, TaskStackSize stackSize_,
-    TaskPeriod periodInSeconds_, TaskDeadlineMissedFunction deadLineMissedFunction_) {
+    TaskPeriod periodInSeconds_, TaskDeadlineMissedFunction deadLineMissedFunction_, void* args) {
   return new FixedTimeslotTask(name_, taskPriority_, stackSize_, periodInSeconds_,
                                deadLineMissedFunction_);
 }

src/fsfw/osal/linux/Clock.cpp

@@ -42,7 +42,7 @@ ReturnValue_t Clock::setClock(const timeval* time) {
   return returnvalue::OK;
 }
 
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
+ReturnValue_t Clock::getClock(timeval* time) {
   timespec timeUnix{};
   int status = clock_gettime(CLOCK_REALTIME, &timeUnix);
   if (status != 0) {
@@ -53,6 +53,8 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
   return returnvalue::OK;
 }
 
+ReturnValue_t Clock::getClock_timeval(timeval* time) { return Clock::getClock(time); }
+
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
   timeval timeVal{};
   ReturnValue_t result = getClock_timeval(&timeVal);
@@ -64,6 +66,17 @@ ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
   return returnvalue::OK;
 }
 
+ReturnValue_t Clock::getClockMonotonic(timeval* time) {
+  timespec timeMonotonic{};
+  int status = clock_gettime(CLOCK_MONOTONIC_RAW, &timeMonotonic);
+  if (status != 0) {
+    return returnvalue::FAILED;
+  }
+  time->tv_sec = timeMonotonic.tv_sec;
+  time->tv_usec = timeMonotonic.tv_nsec / 1000.0;
+  return returnvalue::OK;
+}
+
 timeval Clock::getUptime() {
   timeval uptime{};
   auto result = getUptime(&uptime);
@@ -76,14 +89,17 @@ timeval Clock::getUptime() {
 }
 
 ReturnValue_t Clock::getUptime(timeval* uptime) {
-  // TODO This is not posix compatible and delivers only seconds precision
-  //  Linux specific file read but more precise.
   double uptimeSeconds;
-  if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds) {
+  std::ifstream ifile("/proc/uptime");
+  if (ifile.bad()) {
+    return returnvalue::FAILED;
+  }
+  if (ifile >> uptimeSeconds) {
     uptime->tv_sec = uptimeSeconds;
     uptime->tv_usec = uptimeSeconds * (double)1e6 - (uptime->tv_sec * 1e6);
+    return returnvalue::OK;
   }
-  return returnvalue::OK;
+  return returnvalue::FAILED;
 }
 
 // Wait for new FSFW Clock function delivering seconds uptime.

src/fsfw/osal/linux/FixedTimeslotTask.cpp

@@ -7,10 +7,15 @@
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
 
 FixedTimeslotTask::FixedTimeslotTask(const char* name_, TaskPriority priority_, size_t stackSize_,
-                                     TaskPeriod periodSeconds_, TaskDeadlineMissedFunction dlmFunc_)
+                                     TaskPeriod periodSeconds_, TaskDeadlineMissedFunction dlmFunc_,
+                                     PosixThreadArgs* args)
     : FixedTimeslotTaskBase(periodSeconds_, dlmFunc_),
-      posixThread(name_, priority_, stackSize_),
-      started(false) {}
+      posixThread(name_, SchedulingPolicy::REGULAR, priority_, stackSize_),
+      started(false) {
+  if (args != nullptr) {
+    posixThread.setSchedPolicy(args->policy);
+  }
+}
 
 void* FixedTimeslotTask::taskEntryPoint(void* arg) {
   // The argument is re-interpreted as PollingTask.

src/fsfw/osal/linux/FixedTimeslotTask.h

@@ -23,7 +23,8 @@ class FixedTimeslotTask : public FixedTimeslotTaskBase {
    * @param deadlineMissedFunc_
    */
   FixedTimeslotTask(const char* name_, TaskPriority priority_, size_t stackSize_,
-                    TaskPeriod periodSeconds_, TaskDeadlineMissedFunction dlmFunc_);
+                    TaskPeriod periodSeconds_, TaskDeadlineMissedFunction dlmFunc_,
+                    PosixThreadArgs* args);
   ~FixedTimeslotTask() override = default;
 
   ReturnValue_t startTask() override;

src/fsfw/osal/linux/PeriodicPosixTask.cpp

@@ -4,10 +4,15 @@
 #include "fsfw/tasks/ExecutableObjectIF.h"
 
 PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
-                                     TaskPeriod period_, TaskDeadlineMissedFunction dlmFunc_)
+                                     TaskPeriod period_, TaskDeadlineMissedFunction dlmFunc_,
+                                     PosixThreadArgs* args)
     : PeriodicTaskBase(period_, dlmFunc_),
-      posixThread(name_, priority_, stackSize_),
-      started(false) {}
+      posixThread(name_, SchedulingPolicy::REGULAR, priority_, stackSize_),
+      started(false) {
+  if (args != nullptr) {
+    posixThread.setSchedPolicy(args->policy);
+  }
+}
 
 void* PeriodicPosixTask::taskEntryPoint(void* arg) {
   // The argument is re-interpreted as PollingTask.

src/fsfw/osal/linux/PeriodicPosixTask.h

@@ -24,7 +24,7 @@ class PeriodicPosixTask : public PeriodicTaskBase {
    * @param deadlineMissedFunc_
    */
   PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, TaskPeriod period_,
-                    TaskDeadlineMissedFunction dlmFunc_);
+                    TaskDeadlineMissedFunction dlmFunc_, PosixThreadArgs* args);
   ~PeriodicPosixTask() override = default;
 
   /**

src/fsfw/osal/linux/PosixThread.cpp

@@ -7,8 +7,9 @@
 #include "fsfw/osal/linux/unixUtility.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_)
-    : thread(0), priority(priority_), stackSize(stackSize_) {
+PosixThread::PosixThread(const char* name_, SchedulingPolicy schedPolciy, int priority_,
+                         size_t stackSize_)
+    : thread(0), schedPolicy(schedPolciy), priority(priority_), stackSize(stackSize_) {
   name[0] = '\0';
   std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
 }
@@ -178,20 +179,30 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 #ifndef FSFW_USE_REALTIME_FOR_LINUX
 #error "Please define FSFW_USE_REALTIME_FOR_LINUX with either 0 or 1"
 #endif
+  if (schedPolicy == SchedulingPolicy::RR) {
+    // RR -> This needs root privileges for the process
 #if FSFW_USE_REALTIME_FOR_LINUX == 1
-  // FIFO -> This needs root privileges for the process
-  status = pthread_attr_setschedpolicy(&attributes, SCHED_FIFO);
-  if (status != 0) {
-    utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_attr_setschedpolicy");
+    status = pthread_attr_setschedpolicy(&attributes, SCHED_RR);
+    if (status != 0) {
+      utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_attr_setschedpolicy");
+    }
+    sched_param scheduleParams;
+    scheduleParams.sched_priority = priority;
+    status = pthread_attr_setschedparam(&attributes, &scheduleParams);
+    if (status != 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "PosixThread: Setting priority failed" << std::endl;
+#endif
+    }
+#else
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning
+        << "Real time priorities are only allowed if FSFW_USE_REALTIME_FOR_LINUX is set to 1"
+        << std::endl;
+#endif
+#endif
   }
 
-  sched_param scheduleParams;
-  scheduleParams.__sched_priority = priority;
-  status = pthread_attr_setschedparam(&attributes, &scheduleParams);
-  if (status != 0) {
-    utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_attr_setschedparam");
-  }
-#endif
   // Set Signal Mask for suspend until startTask is called
   sigset_t waitSignal;
   sigemptyset(&waitSignal);
@@ -243,3 +254,5 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
     utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_attr_destroy");
   }
 }
+
+void PosixThread::setSchedPolicy(SchedulingPolicy policy) { this->schedPolicy = policy; }

src/fsfw/osal/linux/PosixThread.h

@@ -9,10 +9,15 @@
 
 #include "../../returnvalues/returnvalue.h"
 
+enum SchedulingPolicy { REGULAR, RR };
+struct PosixThreadArgs {
+  SchedulingPolicy policy = SchedulingPolicy::REGULAR;
+};
+
 class PosixThread {
  public:
   static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
-  PosixThread(const char* name_, int priority_, size_t stackSize_);
+  PosixThread(const char* name_, SchedulingPolicy schedPolicy, int priority_, size_t stackSize_);
   virtual ~PosixThread();
   /**
    * Set the Thread to sleep state
@@ -20,6 +25,9 @@ class PosixThread {
    * @return Returns Failed if sleep fails
    */
   static ReturnValue_t sleep(uint64_t ns);
+
+  void setSchedPolicy(SchedulingPolicy policy);
+
   /**
    * @brief Function to suspend the task until SIGUSR1 was received
    *
@@ -72,6 +80,7 @@ class PosixThread {
 
  private:
   char name[PTHREAD_MAX_NAMELEN];
+  SchedulingPolicy schedPolicy;
   int priority;
   size_t stackSize = 0;
 

src/fsfw/osal/linux/TaskFactory.cpp

@@ -12,18 +12,20 @@ TaskFactory::~TaskFactory() = default;
 
 TaskFactory* TaskFactory::instance() { return TaskFactory::factoryInstance; }
 
-PeriodicTaskIF* TaskFactory::createPeriodicTask(
-    TaskName name_, TaskPriority taskPriority_, TaskStackSize stackSize_,
-    TaskPeriod periodInSeconds_, TaskDeadlineMissedFunction deadLineMissedFunction_) {
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_, TaskPriority taskPriority_,
+                                                TaskStackSize stackSize_,
+                                                TaskPeriod periodInSeconds_,
+                                                TaskDeadlineMissedFunction deadLineMissedFunction_,
+                                                void* args) {
   return new PeriodicPosixTask(name_, taskPriority_, stackSize_, periodInSeconds_,
-                               deadLineMissedFunction_);
+                               deadLineMissedFunction_, reinterpret_cast<PosixThreadArgs*>(args));
 }
 
 FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(
     TaskName name_, TaskPriority taskPriority_, TaskStackSize stackSize_,
-    TaskPeriod periodInSeconds_, TaskDeadlineMissedFunction deadLineMissedFunction_) {
+    TaskPeriod periodInSeconds_, TaskDeadlineMissedFunction deadLineMissedFunction_, void* args) {
   return new FixedTimeslotTask(name_, taskPriority_, stackSize_, periodInSeconds_,
-                               deadLineMissedFunction_);
+                               deadLineMissedFunction_, reinterpret_cast<PosixThreadArgs*>(args));
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {

src/fsfw/osal/rtems/SemaphoreFactory.cpp

@@ -1,5 +1,5 @@
 #include "fsfw/osal/rtems/BinarySemaphore.h"
-//#include "fsfw/osal/rtems/CountingSemaphore.h"
+// #include "fsfw/osal/rtems/CountingSemaphore.h"
 
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/tasks/SemaphoreFactory.h"

src/fsfw/power/DummyPowerSwitcher.cpp

@@ -6,7 +6,11 @@ DummyPowerSwitcher::DummyPowerSwitcher(object_id_t objectId, size_t numberOfSwit
     : SystemObject(objectId, registerGlobally),
       switcherList(numberOfSwitches),
       fuseList(numberOfFuses),
-      switchDelayMs(switchDelayMs) {}
+      switchDelayMs(switchDelayMs) {
+  for (auto &switchState : switcherList) {
+    switchState = PowerSwitchIF::SWITCH_UNKNOWN;
+  }
+}
 
 void DummyPowerSwitcher::setInitialSwitcherList(std::vector<ReturnValue_t> switcherList) {
   this->switcherList = switcherList;

src/fsfw/power/Fuse.h

@@ -32,7 +32,7 @@ class Fuse : public SystemObject,
     gp_id_t poolIdPower;
   };
 
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::POWER_SWITCH_IF;
   //! PSS detected that current on a fuse is totally out of bounds.
   static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, severity::LOW);
   //! PSS detected a fuse that went off.

src/fsfw/power/PowerSwitchIF.h

@@ -28,7 +28,9 @@ class PowerSwitchIF {
   static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
   static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
   static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
+  static const ReturnValue_t SWITCH_UNKNOWN = MAKE_RETURN_CODE(5);
+
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::POWER_SWITCH_IF;
   //!< Someone detected that a switch went off which shouldn't. Severity:
   //!< Low, Parameter1: switchId1, Parameter2: switchId2
   static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, severity::LOW);
@@ -50,6 +52,7 @@ class PowerSwitchIF {
    * @return
    *     - @c SWITCH_ON if the specified switch is on.
    *     - @c SWITCH_OFF if the specified switch is off.
+   *     - @c SWITCH_UNKNOWN if the state of the specified switch is unknown.
    *     - @c returnvalue::FAILED if an error occured
    */
   virtual ReturnValue_t getSwitchState(power::Switch_t switchNr) const = 0;

src/fsfw/power/PowerSwitcherComponent.cpp

@@ -2,6 +2,7 @@
 
 #include <fsfw/ipc/QueueFactory.h>
 #include <fsfw/power/PowerSwitchIF.h>
+#include <fsfw/subsystem/helper.h>
 
 PowerSwitcherComponent::PowerSwitcherComponent(object_id_t objectId, PowerSwitchIF* pwrSwitcher,
                                                power::Switch_t pwrSwitch)
@@ -28,6 +29,9 @@ ReturnValue_t PowerSwitcherComponent::performOperation(uint8_t opCode) {
       continue;
     }
   }
+  if (getHealth() == FAULTY) {
+    performFaultyOperation();
+  }
   if (switcher.active()) {
     switcher.doStateMachine();
     auto currState = switcher.getState();
@@ -111,9 +115,11 @@ const HasHealthIF* PowerSwitcherComponent::getOptHealthIF() const { return this;
 const HasModesIF& PowerSwitcherComponent::getModeIF() const { return *this; }
 
 ReturnValue_t PowerSwitcherComponent::connectModeTreeParent(HasModeTreeChildrenIF& parent) {
-  return parent.registerChild(*this);
+  return modetree::connectModeTreeParent(parent, *this, &healthHelper, modeHelper);
 }
 
 object_id_t PowerSwitcherComponent::getObjectId() const { return SystemObject::getObjectId(); }
 
 ModeTreeChildIF& PowerSwitcherComponent::getModeTreeChildIF() { return *this; }
+
+void PowerSwitcherComponent::performFaultyOperation() {}

src/fsfw/power/PowerSwitcherComponent.h

@@ -1,5 +1,4 @@
-#ifndef _FSFW_POWER_POWERSWITCHERCOMPONENT_H_
-#define _FSFW_POWER_POWERSWITCHERCOMPONENT_H_
+#pragma once
 
 #include <fsfw/health/HasHealthIF.h>
 #include <fsfw/health/HealthHelper.h>
@@ -37,11 +36,13 @@ class PowerSwitcherComponent : public SystemObject,
   ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF &parent) override;
   ModeTreeChildIF &getModeTreeChildIF() override;
 
- private:
-  MessageQueueIF *queue = nullptr;
+ protected:
   PowerSwitcher switcher;
 
-  Mode_t mode = MODE_OFF;
+ private:
+  MessageQueueIF *queue = nullptr;
+
+  Mode_t mode = MODE_UNDEFINED;
   Submode_t submode = 0;
 
   ModeHelper modeHelper;
@@ -49,24 +50,23 @@ class PowerSwitcherComponent : public SystemObject,
 
   void setMode(Mode_t newMode, Submode_t newSubmode);
 
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
 
   ReturnValue_t initialize() override;
 
-  MessageQueueId_t getCommandQueue() const override;
+  [[nodiscard]] MessageQueueId_t getCommandQueue() const override;
   void getMode(Mode_t *mode, Submode_t *submode) override;
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                  uint32_t *msToReachTheMode) override;
   void startTransition(Mode_t mode, Submode_t submode) override;
+  virtual void performFaultyOperation();
   void setToExternalControl() override;
   void announceMode(bool recursive) override;
 
   ReturnValue_t setHealth(HealthState health) override;
   HasHealthIF::HealthState getHealth() override;
 
-  object_id_t getObjectId() const override;
-  const HasHealthIF *getOptHealthIF() const override;
-  const HasModesIF &getModeIF() const override;
+  [[nodiscard]] object_id_t getObjectId() const override;
+  [[nodiscard]] const HasHealthIF *getOptHealthIF() const override;
+  [[nodiscard]] const HasModesIF &getModeIF() const override;
 };
-
-#endif /* _FSFW_POWER_POWERSWITCHERCOMPONENT_H_ */

src/fsfw/pus/CServiceHealthCommanding.cpp

@@ -10,9 +10,23 @@
 CServiceHealthCommanding::CServiceHealthCommanding(HealthServiceCfg args)
     : CommandingServiceBase(args.objectId, args.apid, "PUS 201 Health MGMT", args.service,
                             args.numParallelCommands, args.commandTimeoutSeconds),
-      healthTable(args.table),
+      healthTableId(args.table),
       maxNumHealthInfoPerCycle(args.maxNumHealthInfoPerCycle) {}
 
+ReturnValue_t CServiceHealthCommanding::initialize() {
+  ReturnValue_t result = CommandingServiceBase::initialize();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  healthTable = ObjectManager::instance()->get<HealthTable>(healthTableId);
+  if (healthTable == nullptr) {
+    return returnvalue::FAILED;
+  }
+
+  return returnvalue::OK;
+}
+
 ReturnValue_t CServiceHealthCommanding::isValidSubservice(uint8_t subservice) {
   switch (subservice) {
     case (Subservice::COMMAND_SET_HEALTH):
@@ -68,6 +82,9 @@ ReturnValue_t CServiceHealthCommanding::prepareCommand(CommandMessage *message,
   ReturnValue_t result = returnvalue::OK;
   switch (subservice) {
     case (Subservice::COMMAND_SET_HEALTH): {
+      if (tcDataLen != sizeof(object_id_t) + sizeof(HasHealthIF::HealthState)) {
+        return CommandingServiceBase::INVALID_TC;
+      }
       HealthSetCommand healthCommand;
       result = healthCommand.deSerialize(&tcData, &tcDataLen, SerializeIF::Endianness::BIG);
       if (result != returnvalue::OK) {
@@ -88,14 +105,6 @@ ReturnValue_t CServiceHealthCommanding::prepareCommand(CommandMessage *message,
         return EXECUTION_COMPLETE;
       }
       return result;
-      while (true) {
-        ReturnValue_t result = iterateHealthTable(false);
-        if (result != returnvalue::OK) {
-          break;
-        }
-      }
-
-      return returnvalue::OK;
     }
     default: {
       // Should never happen, subservice was already checked
@@ -142,7 +151,7 @@ void CServiceHealthCommanding::doPeriodicOperation() {
 ReturnValue_t CServiceHealthCommanding::iterateHealthTable(bool reset) {
   std::pair<object_id_t, HasHealthIF::HealthState> pair;
 
-  ReturnValue_t result = healthTable.iterate(&pair, reset);
+  ReturnValue_t result = healthTable->iterate(&pair, reset);
   if (result != returnvalue::OK) {
     return result;
   } else {

src/fsfw/pus/CServiceHealthCommanding.h

@@ -6,7 +6,7 @@
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
 
 struct HealthServiceCfg {
-  HealthServiceCfg(object_id_t objectId, uint16_t apid, HealthTable &healthTable,
+  HealthServiceCfg(object_id_t objectId, uint16_t apid, object_id_t healthTable,
                    uint16_t maxNumHealthInfoPerCycle)
       : objectId(objectId),
         apid(apid),
@@ -14,7 +14,7 @@ struct HealthServiceCfg {
         maxNumHealthInfoPerCycle(maxNumHealthInfoPerCycle) {}
   object_id_t objectId;
   uint16_t apid;
-  HealthTable &table;
+  object_id_t table;
   uint16_t maxNumHealthInfoPerCycle;
   uint8_t service = 201;
   uint8_t numParallelCommands = 4;
@@ -40,6 +40,8 @@ class CServiceHealthCommanding : public CommandingServiceBase {
   CServiceHealthCommanding(HealthServiceCfg args);
   ~CServiceHealthCommanding() override = default;
 
+  ReturnValue_t initialize() override;
+
  protected:
   /* CSB abstract function implementations */
   ReturnValue_t isValidSubservice(uint8_t subservice) override;
@@ -57,7 +59,8 @@ class CServiceHealthCommanding : public CommandingServiceBase {
   void doPeriodicOperation() override;
 
  private:
-  HealthTable &healthTable;
+  const object_id_t healthTableId;
+  HealthTable *healthTable;
   uint16_t maxNumHealthInfoPerCycle = 0;
   bool reportAllHealth = false;
   ReturnValue_t iterateHealthTable(bool reset);

src/fsfw/pus/Service3Housekeeping.cpp

@@ -4,9 +4,10 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/pus/servicepackets/Service3Packets.h"
 
-Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid, uint8_t serviceId)
-    : CommandingServiceBase(objectId, apid, "PUS 3 HK", serviceId, NUM_OF_PARALLEL_COMMANDS,
-                            COMMAND_TIMEOUT_SECONDS) {}
+Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid, uint8_t serviceId,
+                                           uint32_t queueDepth, uint8_t numParallelCommands)
+    : CommandingServiceBase(objectId, apid, "PUS 3 HK", serviceId, numParallelCommands,
+                            COMMAND_TIMEOUT_SECONDS, queueDepth) {}
 
 Service3Housekeeping::~Service3Housekeeping() {}
 

src/fsfw/pus/Service3Housekeeping.h

@@ -28,7 +28,8 @@ class Service3Housekeeping : public CommandingServiceBase, public AcceptsHkPacke
   static constexpr uint8_t NUM_OF_PARALLEL_COMMANDS = 4;
   static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
 
-  Service3Housekeeping(object_id_t objectId, uint16_t apid, uint8_t serviceId);
+  Service3Housekeeping(object_id_t objectId, uint16_t apid, uint8_t serviceId, uint32_t queueDepth,
+                       uint8_t numParallelCommands);
   virtual ~Service3Housekeeping();
 
  protected:

src/fsfw/pus/Service8FunctionManagement.cpp

@@ -9,11 +9,11 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
 Service8FunctionManagement::Service8FunctionManagement(object_id_t objectId, uint16_t apid,
-                                                       uint8_t serviceId,
+                                                       uint8_t serviceId, size_t queueDepth,
                                                        uint8_t numParallelCommands,
                                                        uint16_t commandTimeoutSeconds)
     : CommandingServiceBase(objectId, apid, "PUS 8 Functional Commanding", serviceId,
-                            numParallelCommands, commandTimeoutSeconds) {}
+                            numParallelCommands, commandTimeoutSeconds, queueDepth) {}
 
 Service8FunctionManagement::~Service8FunctionManagement() {}
 

src/fsfw/pus/Service8FunctionManagement.h

@@ -31,7 +31,8 @@
 class Service8FunctionManagement : public CommandingServiceBase {
  public:
   Service8FunctionManagement(object_id_t objectId, uint16_t apid, uint8_t serviceId,
-                             uint8_t numParallelCommands = 4, uint16_t commandTimeoutSeconds = 60);
+                             size_t queueDepth, uint8_t numParallelCommands = 4,
+                             uint16_t commandTimeoutSeconds = 60);
   ~Service8FunctionManagement() override;
 
  protected:

src/fsfw/rmap/rmapStructs.h

@@ -10,11 +10,11 @@
 
 //////////////////////////////////////////////////////////////////////////////////
 // RMAP command bits
-//#define RMAP_COMMAND_BIT_INCREMENT	2
-//#define RMAP_COMMAND_BIT_REPLY		3
-//#define RMAP_COMMAND_BIT_WRITE		5
-//#define RMAP_COMMAND_BIT_VERIFY		4
-//#define RMAP_COMMAND_BIT			6
+// #define RMAP_COMMAND_BIT_INCREMENT	2
+// #define RMAP_COMMAND_BIT_REPLY		3
+// #define RMAP_COMMAND_BIT_WRITE		5
+// #define RMAP_COMMAND_BIT_VERIFY		4
+// #define RMAP_COMMAND_BIT			6
 
 namespace RMAPIds {
 
@@ -32,14 +32,14 @@ static const uint8_t RMAP_COMMAND_READ = ((1 << RMAP_COMMAND_BIT) | (1 << RMAP_C
 static const uint8_t RMAP_REPLY_WRITE =
     ((1 << RMAP_COMMAND_BIT_WRITE) | (1 << RMAP_COMMAND_BIT_REPLY));
 static const uint8_t RMAP_REPLY_READ = ((1 << RMAP_COMMAND_BIT_REPLY));
-//#define RMAP_COMMAND_WRITE			((1<<RMAP_COMMAND_BIT) | (1<<RMAP_COMMAND_BIT_WRITE)
+// #define RMAP_COMMAND_WRITE			((1<<RMAP_COMMAND_BIT) | (1<<RMAP_COMMAND_BIT_WRITE)
 //| (1<<RMAP_COMMAND_BIT_REPLY)) #define RMAP_COMMAND_WRITE_VERIFY	((1<<RMAP_COMMAND_BIT) |
 //(1<<RMAP_COMMAND_BIT_WRITE) | (1<<RMAP_COMMAND_BIT_REPLY) | (1<<RMAP_COMMAND_BIT_VERIFY)) #define
-// RMAP_COMMAND_READ			((1<<RMAP_COMMAND_BIT) | (1<<RMAP_COMMAND_BIT_REPLY))
+//  RMAP_COMMAND_READ			((1<<RMAP_COMMAND_BIT) | (1<<RMAP_COMMAND_BIT_REPLY))
 
-//#define RMAP_REPLY_WRITE			((1<<RMAP_COMMAND_BIT_WRITE) |
+// #define RMAP_REPLY_WRITE			((1<<RMAP_COMMAND_BIT_WRITE) |
 //(1<<RMAP_COMMAND_BIT_REPLY))
-//#define RMAP_REPLY_WRITE_VERIFY		((1<<RMAP_COMMAND_BIT_WRITE) |
+// #define RMAP_REPLY_WRITE_VERIFY		((1<<RMAP_COMMAND_BIT_WRITE) |
 //(1<<RMAP_COMMAND_BIT_REPLY) | (1<<RMAP_COMMAND_BIT_VERIFY)) #define RMAP_REPLY_READ
 //((1<<RMAP_COMMAND_BIT_REPLY))
 
@@ -49,9 +49,9 @@ static const uint8_t RMAP_COMMAND_HEADER_LEN = 16;
 static const uint8_t RMAP_WRITE_REPLY_HEADER_LEN = 8;
 static const uint8_t RMAP_READ_REPLY_HEADER_LEN = 12;
 static const uint8_t RMAP_DATA_FOOTER_SIZE = 1;  // SIZE OF CRC
-//#define RMAP_COMMAND_HEADER_LEN		16
-//#define RMAP_WRITE_REPLY_HEADER_LEN	8
-//#define RMAP_READ_REPLY_HEADER_LEN	12
+// #define RMAP_COMMAND_HEADER_LEN		16
+// #define RMAP_WRITE_REPLY_HEADER_LEN	8
+// #define RMAP_READ_REPLY_HEADER_LEN	12
 
 }  // namespace RMAPIds
 

src/fsfw/storagemanager/PoolManager.cpp

@@ -3,14 +3,14 @@
 #include "fsfw/FSFW.h"
 
 PoolManager::PoolManager(object_id_t setObjectId, const LocalPoolConfig& localPoolConfig)
-    : LocalPool(setObjectId, localPoolConfig, true) {
+    : LocalPool(setObjectId, localPoolConfig, true, true) {
   mutex = MutexFactory::instance()->createMutex();
 }
 
 PoolManager::~PoolManager() { MutexFactory::instance()->deleteMutex(mutex); }
 
 ReturnValue_t PoolManager::reserveSpace(const size_t size, store_address_t* address) {
-  MutexGuard mutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeoutMs);
+  MutexGuard mutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeoutMs, LOCK_CTX);
   ReturnValue_t status = LocalPool::reserveSpace(size, address);
   return status;
 }
@@ -22,12 +22,12 @@ ReturnValue_t PoolManager::deleteData(store_address_t storeId) {
              << storeId.poolIndex << ". id is " << storeId.packetIndex << std::endl;
 #endif
 #endif
-  MutexGuard mutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeoutMs);
+  MutexGuard mutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeoutMs, LOCK_CTX);
   return LocalPool::deleteData(storeId);
 }
 
 ReturnValue_t PoolManager::deleteData(uint8_t* buffer, size_t size, store_address_t* storeId) {
-  MutexGuard mutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+  MutexGuard mutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeoutMs, LOCK_CTX);
   ReturnValue_t status = LocalPool::deleteData(buffer, size, storeId);
   return status;
 }

src/fsfw/storagemanager/PoolManager.h

@@ -56,6 +56,7 @@ class PoolManager : public LocalPool {
  protected:
   //! Default mutex timeout value to prevent permanent blocking.
   uint32_t mutexTimeoutMs = 20;
+  static constexpr char LOCK_CTX[] = "PoolManager";
 
   ReturnValue_t reserveSpace(size_t size, store_address_t* address) override;
 

src/fsfw/subsystem/SubsystemBase.cpp

@@ -21,6 +21,7 @@ SubsystemBase::~SubsystemBase() { QueueFactory::instance()->deleteMessageQueue(c
 
 ReturnValue_t SubsystemBase::checkStateAgainstTable(HybridIterator<ModeListEntry> tableIter,
                                                     Submode_t targetSubmode) {
+  using namespace mode;
   std::map<object_id_t, ChildInfo>::iterator childIter;
 
   for (; tableIter.value != NULL; ++tableIter) {
@@ -34,13 +35,21 @@ ReturnValue_t SubsystemBase::checkStateAgainstTable(HybridIterator<ModeListEntry
       return returnvalue::FAILED;
     }
 
-    Submode_t submodeToCheckAgainst = tableIter.value->getSubmode();
+    // Check submodes here.
+    uint8_t mask;
+    bool submodesAllowedMask = tableIter.value->submodesAllowed(&mask);
+    uint8_t submodeToCheckAgainst = tableIter.value->getSubmode();
     if (tableIter.value->inheritSubmode()) {
       submodeToCheckAgainst = targetSubmode;
     }
-
-    if (childIter->second.submode != submodeToCheckAgainst) {
-      return returnvalue::FAILED;
+    if (submodesAllowedMask) {
+      if ((childIter->second.submode | mask) != mask) {
+        return returnvalue::FAILED;
+      }
+    } else {
+      if (childIter->second.submode != submodeToCheckAgainst) {
+        return returnvalue::FAILED;
+      }
     }
   }
   return returnvalue::OK;
@@ -306,20 +315,7 @@ object_id_t SubsystemBase::getObjectId() const { return SystemObject::getObjectI
 void SubsystemBase::modeChanged() {}
 
 ReturnValue_t SubsystemBase::registerChild(const ModeTreeChildIF& child) {
-  ChildInfo info;
-
-  const HasModesIF& modeChild = child.getModeIF();
-  // intentional to force an initial command during system startup
-  info.commandQueue = modeChild.getCommandQueue();
-  info.mode = HasModesIF::MODE_UNDEFINED;
-  info.submode = SUBMODE_NONE;
-  info.healthChanged = false;
-
-  auto resultPair = childrenMap.emplace(child.getObjectId(), info);
-  if (not resultPair.second) {
-    return COULD_NOT_INSERT_CHILD;
-  }
-  return returnvalue::OK;
+  return registerChild(child.getObjectId(), child.getModeIF().getCommandQueue());
 }
 
 const HasHealthIF* SubsystemBase::getOptHealthIF() const { return this; }
@@ -327,3 +323,19 @@ const HasHealthIF* SubsystemBase::getOptHealthIF() const { return this; }
 const HasModesIF& SubsystemBase::getModeIF() const { return *this; }
 
 ModeTreeChildIF& SubsystemBase::getModeTreeChildIF() { return *this; }
+
+ReturnValue_t SubsystemBase::registerChild(object_id_t childObjectId, MessageQueueId_t childQueue) {
+  ChildInfo info;
+
+  // intentional to force an initial command during system startup
+  info.commandQueue = childQueue;
+  info.mode = HasModesIF::MODE_UNDEFINED;
+  info.submode = SUBMODE_NONE;
+  info.healthChanged = false;
+
+  auto resultPair = childrenMap.emplace(childObjectId, info);
+  if (not resultPair.second) {
+    return COULD_NOT_INSERT_CHILD;
+  }
+  return returnvalue::OK;
+}

src/fsfw/subsystem/SubsystemBase.h

@@ -61,6 +61,8 @@ class SubsystemBase : public SystemObject,
    *           COULD_NOT_INSERT_CHILD If the Child could not be added to the ChildrenMap
    */
   ReturnValue_t registerChild(const ModeTreeChildIF &child) override;
+  // TODO: Add this to HasModeTreeChildrenIF.
+  ReturnValue_t registerChild(object_id_t childObjectId, MessageQueueId_t childQueue);
 
   ReturnValue_t initialize() override;
 

src/fsfw/subsystem/modes/ModeDefinitions.h

@@ -1,111 +1,126 @@
 #ifndef FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_
 #define FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_
 
-#include "../../modes/HasModesIF.h"
-#include "../../objectmanager/SystemObjectIF.h"
-#include "../../serialize/SerialLinkedListAdapter.h"
-#include "../../serialize/SerializeIF.h"
+#include "fsfw/modes/HasModesIF.h"
+#include "fsfw/objectmanager/SystemObjectIF.h"
+#include "fsfw/serialize/SerialLinkedListAdapter.h"
+#include "fsfw/serialize/SerializeIF.h"
 
-class ModeListEntry : public SerializeIF, public LinkedElement<ModeListEntry> {
+namespace mode {
+enum SpecialSubmodeFlags : uint8_t { INHERIT = 1 << 0, ALLOWED_MASK = 1 << 1 };
+}
+
+class ModeListEntry : public SerialLinkedListAdapter<SerializeIF>,
+                      public LinkedElement<ModeListEntry> {
  public:
-  ModeListEntry() : LinkedElement<ModeListEntry>(this) {}
+  static constexpr uint8_t ALL_SUBMODES_ALLOWED_MASK = 0xff;
 
-  uint32_t value1 = 0;
-  uint32_t value2 = 0;
-  uint8_t value3 = 0;
-  uint8_t value4 = 0;
+  ModeListEntry() : SerialLinkedListAdapter(), LinkedElement<ModeListEntry>(this) { setLinks(); }
 
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const {
-    ReturnValue_t result;
+  SerializeElement<uint32_t> value1 = 0;
+  SerializeElement<uint32_t> value2 = 0;
+  SerializeElement<uint8_t> value3 = 0;
+  SerializeElement<uint8_t> value4 = 0;
+  SerializeElement<uint8_t> value5 = 0;
 
-    result = SerializeAdapter::serialize(&value1, buffer, size, maxSize, streamEndianness);
-
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    result = SerializeAdapter::serialize(&value2, buffer, size, maxSize, streamEndianness);
-
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    result = SerializeAdapter::serialize(&value3, buffer, size, maxSize, streamEndianness);
-
-    if (result != returnvalue::OK) {
-      return result;
-    }
-
-    result = SerializeAdapter::serialize(&value4, buffer, size, maxSize, streamEndianness);
-
-    return result;
+  ModeListEntry(const ModeListEntry& other)
+      : SerialLinkedListAdapter(), LinkedElement<ModeListEntry>(this) {
+    value1.entry = other.value1.entry;
+    value2.entry = other.value2.entry;
+    value3.entry = other.value3.entry;
+    value4.entry = other.value4.entry;
+    value5.entry = other.value5.entry;
+    setLinks();
   }
 
-  virtual size_t getSerializedSize() const {
-    return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
+  ModeListEntry& operator=(const ModeListEntry& other) {
+    this->value1.entry = other.value1.entry;
+    this->value2.entry = other.value2.entry;
+    this->value3.entry = other.value3.entry;
+    this->value4.entry = other.value4.entry;
+    this->value5.entry = other.value5.entry;
+    return *this;
   }
 
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    Endianness streamEndianness) {
-    ReturnValue_t result;
-
-    result = SerializeAdapter::deSerialize(&value1, buffer, size, streamEndianness);
-
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    result = SerializeAdapter::deSerialize(&value2, buffer, size, streamEndianness);
-
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    result = SerializeAdapter::deSerialize(&value3, buffer, size, streamEndianness);
-
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    result = SerializeAdapter::deSerialize(&value4, buffer, size, streamEndianness);
-
-    return result;
+  void setLinks() {
+    setStart(&value1);
+    value1.setNext(&value2);
+    value2.setNext(&value3);
+    value3.setNext(&value4);
+    value4.setNext(&value5);
   }
 
   // for Sequences
-  Mode_t getTableId() const { return value1; }
+  Mode_t getTableId() const { return value1.entry; }
 
-  void setTableId(Mode_t tableId) { this->value1 = tableId; }
+  void setTableId(Mode_t tableId) { this->value1.entry = tableId; }
 
-  uint8_t getWaitSeconds() const { return value2; }
+  uint8_t getWaitSeconds() const { return value2.entry; }
 
-  void setWaitSeconds(uint8_t waitSeconds) { this->value2 = waitSeconds; }
+  void setWaitSeconds(uint8_t waitSeconds) { this->value2.entry = waitSeconds; }
 
-  bool checkSuccess() const { return value3 == 1; }
+  bool checkSuccess() const { return value3.entry == 1; }
 
-  void setCheckSuccess(bool checkSuccess) { this->value3 = checkSuccess; }
+  void setCheckSuccess(bool checkSuccess) { this->value3.entry = checkSuccess; }
 
   // for Tables
-  object_id_t getObject() const { return value1; }
+  object_id_t getObject() const { return value1.entry; }
 
-  void setObject(object_id_t object) { this->value1 = object; }
+  void setObject(object_id_t object) { this->value1.entry = object; }
 
-  Mode_t getMode() const { return value2; }
+  Mode_t getMode() const { return value2.entry; }
 
-  void setMode(Mode_t mode) { this->value2 = mode; }
+  void setMode(Mode_t mode) { this->value2.entry = mode; }
 
-  Submode_t getSubmode() const { return value3; }
+  Submode_t getSubmode() const { return value3.entry; }
 
-  void setSubmode(Submode_t submode) { this->value3 = submode; }
+  void setSubmode(Submode_t submode) { this->value3.entry = submode; }
 
-  bool inheritSubmode() const { return value4 == 1; }
-
-  void setInheritSubmode(bool inherit) {
-    if (inherit) {
-      value4 = 1;
-    } else {
-      value4 = 0;
+  bool inheritSubmode() const {
+    return (value4.entry & mode::SpecialSubmodeFlags::INHERIT) ==
+           mode::SpecialSubmodeFlags::INHERIT;
+  }
+  bool submodesAllowed(uint8_t* mask) const {
+    bool submodesAllowed = (value4.entry & mode::SpecialSubmodeFlags::ALLOWED_MASK) ==
+                           mode::SpecialSubmodeFlags::ALLOWED_MASK;
+    if (submodesAllowed and mask != nullptr) {
+      *mask = value5.entry;
     }
+    return submodesAllowed;
   }
 
-  bool operator==(ModeListEntry other) {
-    return ((value1 == other.value1) && (value2 == other.value2) && (value3 == other.value3));
+  /**
+   * Enable the inheritance of submodes. This is relevant for both the execution
+   * of mode tables and for mode checking.
+   */
+  void enableInheritSubmode() { value4.entry |= mode::SpecialSubmodeFlags::INHERIT; }
+  /**
+   * Disable the inheritance of submodes. This is relevant for both the execution
+   * of mode tables and for mode checking.
+   */
+  void disableInheritSubmode() { value4.entry &= ~mode::SpecialSubmodeFlags::INHERIT; }
+
+  /**
+   * Specialization of @enableSubmodeAllowed which allows all submodes.
+   */
+  void allowAllSubmodes() { enableSubmodeAllowed(ALL_SUBMODES_ALLOWED_MASK); }
+
+  /**
+   * Enable an allowed submode mask for mode checks. Any submode which contains bits
+   * outside of the mask will be declined.
+   *
+   * For example, for a mask of 0b11, only the modes 0b00, 0b01 and 0b11 will be accepted.
+   */
+  void enableSubmodeAllowed(uint8_t mask) {
+    value4.entry |= mode::SpecialSubmodeFlags::ALLOWED_MASK;
+    value5.entry = mask;
+  }
+  /**
+   * Enforce the equality of submodes for mode checks. This is the default.
+   */
+  void disableSubmodeAllowed() {
+    value4.entry &= ~mode::SpecialSubmodeFlags::ALLOWED_MASK;
+    value5.entry = 0;
   }
 };
 

src/fsfw/tasks/TaskFactory.h

@@ -47,7 +47,8 @@ class TaskFactory {
    */
   PeriodicTaskIF* createPeriodicTask(TaskName name_, TaskPriority taskPriority_,
                                      TaskStackSize stackSize_, TaskPeriod periodInSeconds_,
-                                     TaskDeadlineMissedFunction deadLineMissedFunction_);
+                                     TaskDeadlineMissedFunction deadLineMissedFunction_,
+                                     void* args = nullptr);
 
   /**
    * The meaning for the variables for fixed timeslot tasks is the same as for periodic tasks.
@@ -62,7 +63,8 @@ class TaskFactory {
   FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_, TaskPriority taskPriority_,
                                                TaskStackSize stackSize_,
                                                TaskPeriod periodInSeconds_,
-                                               TaskDeadlineMissedFunction deadLineMissedFunction_);
+                                               TaskDeadlineMissedFunction deadLineMissedFunction_,
+                                               void* args = nullptr);
 
   /**
    * Function to be called to delete a task

src/fsfw/thermal/Heater.cpp

@@ -283,7 +283,7 @@ ReturnValue_t Heater::getParameter(uint8_t domainId, uint8_t uniqueId,
   }
   switch (uniqueId) {
     case 0:
-      parameterWrapper->set(heaterOnCountdown.timeout);
+      parameterWrapper->set(heaterOnCountdown.getTimeoutMs());
       break;
     default:
       return INVALID_IDENTIFIER_ID;

src/fsfw/timemanager/Clock.h

@@ -49,6 +49,13 @@ class Clock {
    * @return	-@c returnvalue::OK on success. Otherwise, the OS failure code is returned.
    */
   static ReturnValue_t setClock(const timeval *time);
+
+  /**
+   * @deprecated Use getClock instead, which does the same.
+   * @param time
+   * @return
+   */
+  static ReturnValue_t getClock_timeval(timeval *time);
   /**
    * This system call returns the current system clock in timeval format.
    * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
@@ -56,7 +63,18 @@ class Clock {
    * @param time	A pointer to a timeval struct where the current time is stored.
    * @return @c returnvalue::OK on success. Otherwise, the OS failure code is returned.
    */
-  static ReturnValue_t getClock_timeval(timeval *time);
+  static ReturnValue_t getClock(timeval *time);
+
+  /**
+   * Retrieve a monotonic clock. This clock this is also more suited for measuring elapsed times
+   * between two time points, but less suited when the absolute time is required.
+   *
+   * Implementation example: A generic UNIX implementation can use CLOCK_MONOTONIC_RAW with
+   * `clock_gettime`.
+   * @param time
+   * @return
+   */
+  static ReturnValue_t getClockMonotonic(timeval *time);
 
   /**
    * Get the time since boot in a timeval struct

src/fsfw/timemanager/Countdown.cpp

@@ -1,49 +1,62 @@
 #include "fsfw/timemanager/Countdown.h"
 
-Countdown::Countdown(uint32_t initialTimeout, bool startImmediately) : timeout(initialTimeout) {
+#include "fsfw/globalfunctions/timevalOperations.h"
+
+Countdown::Countdown(uint32_t initialTimeout, bool startImmediately) {
   if (startImmediately) {
     setTimeout(initialTimeout);
   } else {
-    timeout = initialTimeout;
+    timeout.tv_sec = initialTimeout / 1000;
+    timeout.tv_usec = (initialTimeout % 1000) * 1000;
   }
 }
 
-Countdown::~Countdown() {}
+Countdown::~Countdown() = default;
 
 ReturnValue_t Countdown::setTimeout(uint32_t milliseconds) {
-  ReturnValue_t returnValue = Clock::getUptime(&startTime);
-  timeout = milliseconds;
-  return returnValue;
+  timeout.tv_sec = milliseconds / 1000;
+  timeout.tv_usec = (milliseconds % 1000) * 1000;
+  return Clock::getClockMonotonic(&startTime);
 }
 
 bool Countdown::hasTimedOut() const {
-  if (uint32_t(this->getCurrentTime() - startTime) >= timeout) {
+  // Account for system clock going back in time.
+  if (getCurrentTime() < startTime) {
     return true;
-  } else {
-    return false;
   }
+  if (getCurrentTime() - startTime >= timeout) {
+    return true;
+  }
+  return false;
 }
 
 bool Countdown::isBusy() const { return !hasTimedOut(); }
 
-ReturnValue_t Countdown::resetTimer() { return setTimeout(timeout); }
+ReturnValue_t Countdown::resetTimer() { return setTimeoutTv(timeout); }
 
 void Countdown::timeOut() { startTime = this->getCurrentTime() - timeout; }
 
 uint32_t Countdown::getRemainingMillis() const {
-  // We fetch the time before the if-statement
-  // to be sure that the return is in
-  // range 0 <= number <= timeout
-  uint32_t currentTime = this->getCurrentTime();
   if (this->hasTimedOut()) {
     return 0;
-  } else {
-    return (startTime + timeout) - currentTime;
   }
+  timeval remainingMillisTv = (startTime + timeout) - this->getCurrentTime();
+  return remainingMillisTv.tv_sec * 1000 + remainingMillisTv.tv_usec / 1000;
 }
 
-uint32_t Countdown::getCurrentTime() const {
-  uint32_t currentTime;
-  Clock::getUptime(&currentTime);
+uint32_t Countdown::timevalToMs(timeval &tv) { return tv.tv_sec * 1000 + tv.tv_usec / 1000; }
+
+ReturnValue_t Countdown::setTimeoutTv(timeval tv) {
+  timeout = tv;
+  return Clock::getClockMonotonic(&startTime);
+}
+
+uint32_t Countdown::getTimeoutMs() const { return timeout.tv_sec * 1000 + timeout.tv_usec / 1000; }
+
+timeval Countdown::getTimeout() const { return timeout; }
+
+timeval Countdown::getCurrentTime() const {
+  timeval currentTime{};
+  Clock::getClockMonotonic(&currentTime);
   return currentTime;
 }

src/fsfw/timemanager/Countdown.h

@@ -6,6 +6,10 @@
 /**
  *
  * Countdown keeps track of a timespan.
+ * This class uses the system clock internally to achieve
+ * a high resolution. This means that the API is only partially
+ * resistant against time jumps. The user must take care to account
+ * for time jumps in some from if this relevant.
  *
  * Countdown::resetTimer restarts the timer.
  * Countdown::setTimeout sets a new countdown duration and resets.
@@ -39,6 +43,8 @@ class Countdown {
    * @return Returnvalue from Clock::getUptime
    */
   ReturnValue_t setTimeout(uint32_t milliseconds);
+  ReturnValue_t setTimeoutTv(timeval tv);
+
   /**
    * Returns true if the countdown duration has passed.
    *
@@ -61,22 +67,31 @@ class Countdown {
    * Returns the remaining milliseconds (0 if timeout)
    */
   uint32_t getRemainingMillis() const;
+
+  uint32_t getTimeoutMs() const;
+
+  timeval getTimeout() const;
+
   /**
    * Makes hasTimedOut() return true
    */
   void timeOut();
-  /**
-   * Internal countdown duration in milliseconds
-   */
-  uint32_t timeout;
+
+  static inline uint32_t timevalToMs(timeval& tv);
 
  private:
   /**
-   * Last time the timer was started (uptime)
+   * Start time of the countdown.
    */
-  uint32_t startTime = 0;
+  timeval startTime{};
 
-  uint32_t getCurrentTime() const;
+  /**
+   * Timeout as timeval type. The countdown has timed out when the
+   * current time exceeds the start time plus the timeout.
+   */
+  timeval timeout{};
+
+  timeval getCurrentTime() const;
 };
 
 #endif /* FSFW_TIMEMANAGER_COUNTDOWN_H_ */

src/fsfw/timemanager/Stopwatch.cpp

@@ -9,10 +9,10 @@
 Stopwatch::Stopwatch(bool displayOnDestruction, StopwatchDisplayMode displayMode)
     : displayOnDestruction(displayOnDestruction), displayMode(displayMode) {
   // Measures start time on initialization.
-  Clock::getClock_timeval(&startTime);
+  Clock::getClockMonotonic(&startTime);
 }
 
-void Stopwatch::start() { Clock::getUptime(&startTime); }
+void Stopwatch::start() { Clock::getClockMonotonic(&startTime); }
 
 dur_millis_t Stopwatch::stop(bool display) {
   stopInternal();
@@ -63,6 +63,6 @@ StopwatchDisplayMode Stopwatch::getDisplayMode() const { return displayMode; }
 
 void Stopwatch::stopInternal() {
   timeval endTime;
-  Clock::getClock_timeval(&endTime);
+  Clock::getClockMonotonic(&endTime);
   elapsedTime = endTime - startTime;
 }

src/fsfw/tmtcpacket/pus/tm/PusTmCreator.h

@@ -40,7 +40,7 @@ struct PusTmParams {
               size_t dataLen)
       : secHeader(service, subservice, timeStamper), adapter(data, dataLen), sourceData(&adapter) {}
   PusTmSecHeader secHeader;
-  SerialBufferAdapter<uint8_t> adapter;
+  SerialBufferAdapter<size_t> adapter;
   const SerializeIF* sourceData = nullptr;
 };
 

src/fsfw/tmtcpacket/pus/tm/PusTmZcWriter.cpp

@@ -24,3 +24,9 @@ void PusTmZeroCopyWriter::updateErrorControl() {
   crcStart[0] = (crc16 >> 8) & 0xff;
   crcStart[1] = crc16 & 0xff;
 }
+
+void PusTmZeroCopyWriter::setMessageCount(uint16_t msgCount) {
+  size_t serSize = 0;
+  SerializeAdapter::serialize(&msgCount, const_cast<uint8_t*>(pointers.secHeaderStart + 3),
+                              &serSize, 2, SerializeIF::Endianness::NETWORK);
+}

src/fsfw/tmtcpacket/pus/tm/PusTmZcWriter.h

@@ -14,6 +14,7 @@ class PusTmZeroCopyWriter : public PusTmReader {
   PusTmZeroCopyWriter(TimeReaderIF& timeReader, uint8_t* data, size_t size);
 
   void setSequenceCount(uint16_t seqCount);
+  void setMessageCount(uint16_t msgCount);
   void updateErrorControl();
 
  private:

src/fsfw/tmtcservices/TmTcBridge.cpp

@@ -8,7 +8,7 @@
 #define TMTCBRIDGE_WIRETAPPING 0
 
 TmTcBridge::TmTcBridge(const char* name, object_id_t objectId, object_id_t tcDestination,
-                       object_id_t tmStoreId, object_id_t tcStoreId)
+                       uint32_t msgQueueDepth, object_id_t tmStoreId, object_id_t tcStoreId)
     : SystemObject(objectId),
       name(name),
       tmStoreId(tmStoreId),
@@ -18,7 +18,7 @@ TmTcBridge::TmTcBridge(const char* name, object_id_t objectId, object_id_t tcDes
 {
   auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
   tmTcReceptionQueue = QueueFactory::instance()->createMessageQueue(
-      TMTC_RECEPTION_QUEUE_DEPTH, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+      msgQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 TmTcBridge::~TmTcBridge() { QueueFactory::instance()->deleteMessageQueue(tmTcReceptionQueue); }

src/fsfw/tmtcservices/TmTcBridge.h

@@ -15,7 +15,6 @@ class TmTcBridge : public AcceptsTelemetryIF,
                    public ExecutableObjectIF,
                    public SystemObject {
  public:
-  static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
   static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15;
   static constexpr unsigned int LIMIT_DOWNLINK_PACKETS_STORED = 500;
 
@@ -23,7 +22,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
   static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
 
   TmTcBridge(const char* name, object_id_t objectId, object_id_t tcDestination,
-             object_id_t tmStoreId, object_id_t tcStoreId);
+             uint32_t msgQueueDepth, object_id_t tmStoreId, object_id_t tcStoreId);
   ~TmTcBridge() override;
 
   /**

src/fsfw_hal/common/spi/spiCommon.h

@@ -5,8 +5,18 @@
 
 namespace spi {
 
+static constexpr uint8_t CLASS_ID = CLASS_ID::HAL_SPI;
+static constexpr ReturnValue_t OPENING_FILE_FAILED = returnvalue::makeCode(CLASS_ID, 0);
+/* Full duplex (ioctl) transfer failure */
+static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED = returnvalue::makeCode(CLASS_ID, 1);
+/* Half duplex (read/write) transfer failure */
+static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED = returnvalue::makeCode(CLASS_ID, 2);
+static constexpr ReturnValue_t TIMEOUT = returnvalue::makeCode(CLASS_ID, 3);
+static constexpr ReturnValue_t BUSY = returnvalue::makeCode(CLASS_ID, 4);
+static constexpr ReturnValue_t GENERIC_ERROR = returnvalue::makeCode(CLASS_ID, 5);
+
 enum SpiModes : uint8_t { MODE_0, MODE_1, MODE_2, MODE_3 };
 
-}
+}  // namespace spi
 
 #endif /* FSFW_HAL_COMMON_SPI_SPICOMMON_H_ */

src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -10,11 +10,11 @@ MgmLIS3MDLHandler::MgmLIS3MDLHandler(object_id_t objectId, object_id_t deviceCom
       dataset(this),
       transitionDelay(transitionDelay) {
   // Set to default values right away
-  registers[0] = MGMLIS3MDL::CTRL_REG1_DEFAULT;
-  registers[1] = MGMLIS3MDL::CTRL_REG2_DEFAULT;
-  registers[2] = MGMLIS3MDL::CTRL_REG3_DEFAULT;
-  registers[3] = MGMLIS3MDL::CTRL_REG4_DEFAULT;
-  registers[4] = MGMLIS3MDL::CTRL_REG5_DEFAULT;
+  registers[0] = mgmLis3::CTRL_REG1_DEFAULT;
+  registers[1] = mgmLis3::CTRL_REG2_DEFAULT;
+  registers[2] = mgmLis3::CTRL_REG3_DEFAULT;
+  registers[3] = mgmLis3::CTRL_REG4_DEFAULT;
+  registers[4] = mgmLis3::CTRL_REG5_DEFAULT;
 }
 
 MgmLIS3MDLHandler::~MgmLIS3MDLHandler() {}
@@ -63,15 +63,15 @@ ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(DeviceCommandId_t
       return DeviceHandlerBase::NOTHING_TO_SEND;
     }
     case (InternalState::STATE_FIRST_CONTACT): {
-      *id = MGMLIS3MDL::IDENTIFY_DEVICE;
+      *id = mgmLis3::IDENTIFY_DEVICE;
       break;
     }
     case (InternalState::STATE_SETUP): {
-      *id = MGMLIS3MDL::SETUP_MGM;
+      *id = mgmLis3::SETUP_MGM;
       break;
     }
     case (InternalState::STATE_CHECK_REGISTERS): {
-      *id = MGMLIS3MDL::READ_CONFIG_AND_DATA;
+      *id = mgmLis3::READ_CONFIG_AND_DATA;
       break;
     }
     default: {
@@ -88,28 +88,12 @@ ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(DeviceCommandId_t
   return buildCommandFromCommand(*id, NULL, 0);
 }
 
-uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) {
-  command |= (1 << MGMLIS3MDL::RW_BIT);
-  if (continuousCom == true) {
-    command |= (1 << MGMLIS3MDL::MS_BIT);
-  }
-  return command;
-}
-
-uint8_t MgmLIS3MDLHandler::writeCommand(uint8_t command, bool continuousCom) {
-  command &= ~(1 << MGMLIS3MDL::RW_BIT);
-  if (continuousCom == true) {
-    command |= (1 << MGMLIS3MDL::MS_BIT);
-  }
-  return command;
-}
-
 void MgmLIS3MDLHandler::setupMgm() {
-  registers[0] = MGMLIS3MDL::CTRL_REG1_DEFAULT;
-  registers[1] = MGMLIS3MDL::CTRL_REG2_DEFAULT;
-  registers[2] = MGMLIS3MDL::CTRL_REG3_DEFAULT;
-  registers[3] = MGMLIS3MDL::CTRL_REG4_DEFAULT;
-  registers[4] = MGMLIS3MDL::CTRL_REG5_DEFAULT;
+  registers[0] = mgmLis3::CTRL_REG1_DEFAULT;
+  registers[1] = mgmLis3::CTRL_REG2_DEFAULT;
+  registers[2] = mgmLis3::CTRL_REG3_DEFAULT;
+  registers[3] = mgmLis3::CTRL_REG4_DEFAULT;
+  registers[4] = mgmLis3::CTRL_REG5_DEFAULT;
 
   prepareCtrlRegisterWrite();
 }
@@ -117,11 +101,11 @@ void MgmLIS3MDLHandler::setupMgm() {
 ReturnValue_t MgmLIS3MDLHandler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   // Data/config register will be read in an alternating manner.
   if (communicationStep == CommunicationStep::DATA) {
-    *id = MGMLIS3MDL::READ_CONFIG_AND_DATA;
+    *id = mgmLis3::READ_CONFIG_AND_DATA;
     communicationStep = CommunicationStep::TEMPERATURE;
     return buildCommandFromCommand(*id, NULL, 0);
   } else {
-    *id = MGMLIS3MDL::READ_TEMPERATURE;
+    *id = mgmLis3::READ_TEMPERATURE;
     communicationStep = CommunicationStep::DATA;
     return buildCommandFromCommand(*id, NULL, 0);
   }
@@ -131,33 +115,33 @@ ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(DeviceCommandId_t devic
                                                          const uint8_t *commandData,
                                                          size_t commandDataLen) {
   switch (deviceCommand) {
-    case (MGMLIS3MDL::READ_CONFIG_AND_DATA): {
+    case (mgmLis3::READ_CONFIG_AND_DATA): {
       std::memset(commandBuffer, 0, sizeof(commandBuffer));
-      commandBuffer[0] = readCommand(MGMLIS3MDL::CTRL_REG1, true);
+      commandBuffer[0] = mgmLis3::readCommand(mgmLis3::CTRL_REG1, true);
 
       rawPacket = commandBuffer;
-      rawPacketLen = MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1;
+      rawPacketLen = mgmLis3::NR_OF_DATA_AND_CFG_REGISTERS + 1;
       return returnvalue::OK;
     }
-    case (MGMLIS3MDL::READ_TEMPERATURE): {
+    case (mgmLis3::READ_TEMPERATURE): {
       std::memset(commandBuffer, 0, 3);
-      commandBuffer[0] = readCommand(MGMLIS3MDL::TEMP_LOWBYTE, true);
+      commandBuffer[0] = mgmLis3::readCommand(mgmLis3::TEMP_LOWBYTE, true);
 
       rawPacket = commandBuffer;
       rawPacketLen = 3;
       return returnvalue::OK;
     }
-    case (MGMLIS3MDL::IDENTIFY_DEVICE): {
+    case (mgmLis3::IDENTIFY_DEVICE): {
       return identifyDevice();
     }
-    case (MGMLIS3MDL::TEMP_SENSOR_ENABLE): {
+    case (mgmLis3::TEMP_SENSOR_ENABLE): {
       return enableTemperatureSensor(commandData, commandDataLen);
     }
-    case (MGMLIS3MDL::SETUP_MGM): {
+    case (mgmLis3::SETUP_MGM): {
       setupMgm();
       return returnvalue::OK;
     }
-    case (MGMLIS3MDL::ACCURACY_OP_MODE_SET): {
+    case (mgmLis3::ACCURACY_OP_MODE_SET): {
       return setOperatingMode(commandData, commandDataLen);
     }
     default:
@@ -168,7 +152,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(DeviceCommandId_t devic
 
 ReturnValue_t MgmLIS3MDLHandler::identifyDevice() {
   uint32_t size = 2;
-  commandBuffer[0] = readCommand(MGMLIS3MDL::IDENTIFY_DEVICE_REG_ADDR);
+  commandBuffer[0] = mgmLis3::readCommand(mgmLis3::IDENTIFY_DEVICE_REG_ADDR);
   commandBuffer[1] = 0x00;
 
   rawPacket = commandBuffer;
@@ -180,9 +164,9 @@ ReturnValue_t MgmLIS3MDLHandler::identifyDevice() {
 ReturnValue_t MgmLIS3MDLHandler::scanForReply(const uint8_t *start, size_t len,
                                               DeviceCommandId_t *foundId, size_t *foundLen) {
   *foundLen = len;
-  if (len == MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1) {
+  if (len == mgmLis3::NR_OF_DATA_AND_CFG_REGISTERS + 1) {
     *foundLen = len;
-    *foundId = MGMLIS3MDL::READ_CONFIG_AND_DATA;
+    *foundId = mgmLis3::READ_CONFIG_AND_DATA;
     // Check validity by checking config registers
     if (start[1] != registers[0] or start[2] != registers[1] or start[3] != registers[2] or
         start[4] != registers[3] or start[5] != registers[4]) {
@@ -199,17 +183,17 @@ ReturnValue_t MgmLIS3MDLHandler::scanForReply(const uint8_t *start, size_t len,
       commandExecuted = true;
     }
 
-  } else if (len == MGMLIS3MDL::TEMPERATURE_REPLY_LEN) {
+  } else if (len == mgmLis3::TEMPERATURE_REPLY_LEN) {
     *foundLen = len;
-    *foundId = MGMLIS3MDL::READ_TEMPERATURE;
-  } else if (len == MGMLIS3MDL::SETUP_REPLY_LEN) {
+    *foundId = mgmLis3::READ_TEMPERATURE;
+  } else if (len == mgmLis3::SETUP_REPLY_LEN) {
     *foundLen = len;
-    *foundId = MGMLIS3MDL::SETUP_MGM;
+    *foundId = mgmLis3::SETUP_MGM;
   } else if (len == SINGLE_COMMAND_ANSWER_LEN) {
     *foundLen = len;
     *foundId = getPendingCommand();
-    if (*foundId == MGMLIS3MDL::IDENTIFY_DEVICE) {
-      if (start[1] != MGMLIS3MDL::DEVICE_ID) {
+    if (*foundId == mgmLis3::IDENTIFY_DEVICE) {
+      if (start[1] != mgmLis3::DEVICE_ID) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "MGMHandlerLIS3MDL::scanForReply: "
@@ -241,30 +225,31 @@ ReturnValue_t MgmLIS3MDLHandler::scanForReply(const uint8_t *start, size_t len,
 }
 ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
   switch (id) {
-    case MGMLIS3MDL::IDENTIFY_DEVICE: {
+    case mgmLis3::IDENTIFY_DEVICE: {
       break;
     }
-    case MGMLIS3MDL::SETUP_MGM: {
+    case mgmLis3::SETUP_MGM: {
       break;
     }
-    case MGMLIS3MDL::READ_CONFIG_AND_DATA: {
+    case mgmLis3::READ_CONFIG_AND_DATA: {
+      using namespace mgmLis3;
       // TODO: Store configuration in new local datasets.
       float sensitivityFactor = getSensitivityFactor(getSensitivity(registers[2]));
 
       int16_t mgmMeasurementRawX =
-          packet[MGMLIS3MDL::X_HIGHBYTE_IDX] << 8 | packet[MGMLIS3MDL::X_LOWBYTE_IDX];
+          packet[mgmLis3::X_HIGHBYTE_IDX] << 8 | packet[mgmLis3::X_LOWBYTE_IDX];
       int16_t mgmMeasurementRawY =
-          packet[MGMLIS3MDL::Y_HIGHBYTE_IDX] << 8 | packet[MGMLIS3MDL::Y_LOWBYTE_IDX];
+          packet[mgmLis3::Y_HIGHBYTE_IDX] << 8 | packet[mgmLis3::Y_LOWBYTE_IDX];
       int16_t mgmMeasurementRawZ =
-          packet[MGMLIS3MDL::Z_HIGHBYTE_IDX] << 8 | packet[MGMLIS3MDL::Z_LOWBYTE_IDX];
+          packet[mgmLis3::Z_HIGHBYTE_IDX] << 8 | packet[mgmLis3::Z_LOWBYTE_IDX];
 
       // Target value in microtesla
       float mgmX = static_cast<float>(mgmMeasurementRawX) * sensitivityFactor *
-                   MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR;
+                   mgmLis3::GAUSS_TO_MICROTESLA_FACTOR;
       float mgmY = static_cast<float>(mgmMeasurementRawY) * sensitivityFactor *
-                   MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR;
+                   mgmLis3::GAUSS_TO_MICROTESLA_FACTOR;
       float mgmZ = static_cast<float>(mgmMeasurementRawZ) * sensitivityFactor *
-                   MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR;
+                   mgmLis3::GAUSS_TO_MICROTESLA_FACTOR;
 
       if (periodicPrintout) {
         if (debugDivider.checkAndIncrement()) {
@@ -306,7 +291,7 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
       break;
     }
 
-    case MGMLIS3MDL::READ_TEMPERATURE: {
+    case mgmLis3::READ_TEMPERATURE: {
       int16_t tempValueRaw = packet[2] << 8 | packet[1];
       float tempValue = 25.0 + ((static_cast<float>(tempValueRaw)) / 8.0);
       if (periodicPrintout) {
@@ -334,41 +319,6 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
   return returnvalue::OK;
 }
 
-MGMLIS3MDL::Sensitivies MgmLIS3MDLHandler::getSensitivity(uint8_t ctrlRegister2) {
-  bool fs0Set = ctrlRegister2 & (1 << MGMLIS3MDL::FSO);  // Checks if FS0 bit is set
-  bool fs1Set = ctrlRegister2 & (1 << MGMLIS3MDL::FS1);  // Checks if FS1 bit is set
-
-  if (fs0Set && fs1Set)
-    return MGMLIS3MDL::Sensitivies::GAUSS_16;
-  else if (!fs0Set && fs1Set)
-    return MGMLIS3MDL::Sensitivies::GAUSS_12;
-  else if (fs0Set && !fs1Set)
-    return MGMLIS3MDL::Sensitivies::GAUSS_8;
-  else
-    return MGMLIS3MDL::Sensitivies::GAUSS_4;
-}
-
-float MgmLIS3MDLHandler::getSensitivityFactor(MGMLIS3MDL::Sensitivies sens) {
-  switch (sens) {
-    case (MGMLIS3MDL::GAUSS_4): {
-      return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_4_SENS;
-    }
-    case (MGMLIS3MDL::GAUSS_8): {
-      return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_8_SENS;
-    }
-    case (MGMLIS3MDL::GAUSS_12): {
-      return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_12_SENS;
-    }
-    case (MGMLIS3MDL::GAUSS_16): {
-      return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_16_SENS;
-    }
-    default: {
-      // Should never happen
-      return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_4_SENS;
-    }
-  }
-}
-
 ReturnValue_t MgmLIS3MDLHandler::enableTemperatureSensor(const uint8_t *commandData,
                                                          size_t commandDataLen) {
   if (commandData == nullptr) {
@@ -376,16 +326,16 @@ ReturnValue_t MgmLIS3MDLHandler::enableTemperatureSensor(const uint8_t *commandD
   }
   triggerEvent(CHANGE_OF_SETUP_PARAMETER);
   uint32_t size = 2;
-  commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1);
+  commandBuffer[0] = mgmLis3::writeCommand(mgmLis3::CTRL_REG1);
   if (commandDataLen > 1) {
     return INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
   }
   switch (commandData[0]) {
-    case (MGMLIS3MDL::ON): {
+    case (mgmLis3::ON): {
       commandBuffer[1] = registers[0] | (1 << 7);
       break;
     }
-    case (MGMLIS3MDL::OFF): {
+    case (mgmLis3::OFF): {
       commandBuffer[1] = registers[0] & ~(1 << 7);
       break;
     }
@@ -408,23 +358,23 @@ ReturnValue_t MgmLIS3MDLHandler::setOperatingMode(const uint8_t *commandData,
   }
 
   switch (commandData[0]) {
-    case MGMLIS3MDL::LOW:
-      registers[0] = (registers[0] & (~(1 << MGMLIS3MDL::OM1))) & (~(1 << MGMLIS3MDL::OM0));
-      registers[3] = (registers[3] & (~(1 << MGMLIS3MDL::OMZ1))) & (~(1 << MGMLIS3MDL::OMZ0));
+    case mgmLis3::LOW:
+      registers[0] = (registers[0] & (~(1 << mgmLis3::OM1))) & (~(1 << mgmLis3::OM0));
+      registers[3] = (registers[3] & (~(1 << mgmLis3::OMZ1))) & (~(1 << mgmLis3::OMZ0));
       break;
-    case MGMLIS3MDL::MEDIUM:
-      registers[0] = (registers[0] & (~(1 << MGMLIS3MDL::OM1))) | (1 << MGMLIS3MDL::OM0);
-      registers[3] = (registers[3] & (~(1 << MGMLIS3MDL::OMZ1))) | (1 << MGMLIS3MDL::OMZ0);
+    case mgmLis3::MEDIUM:
+      registers[0] = (registers[0] & (~(1 << mgmLis3::OM1))) | (1 << mgmLis3::OM0);
+      registers[3] = (registers[3] & (~(1 << mgmLis3::OMZ1))) | (1 << mgmLis3::OMZ0);
       break;
 
-    case MGMLIS3MDL::HIGH:
-      registers[0] = (registers[0] | (1 << MGMLIS3MDL::OM1)) & (~(1 << MGMLIS3MDL::OM0));
-      registers[3] = (registers[3] | (1 << MGMLIS3MDL::OMZ1)) & (~(1 << MGMLIS3MDL::OMZ0));
+    case mgmLis3::HIGH:
+      registers[0] = (registers[0] | (1 << mgmLis3::OM1)) & (~(1 << mgmLis3::OM0));
+      registers[3] = (registers[3] | (1 << mgmLis3::OMZ1)) & (~(1 << mgmLis3::OMZ0));
       break;
 
-    case MGMLIS3MDL::ULTRA:
-      registers[0] = (registers[0] | (1 << MGMLIS3MDL::OM1)) | (1 << MGMLIS3MDL::OM0);
-      registers[3] = (registers[3] | (1 << MGMLIS3MDL::OMZ1)) | (1 << MGMLIS3MDL::OMZ0);
+    case mgmLis3::ULTRA:
+      registers[0] = (registers[0] | (1 << mgmLis3::OM1)) | (1 << mgmLis3::OM0);
+      registers[3] = (registers[3] | (1 << mgmLis3::OMZ1)) | (1 << mgmLis3::OMZ0);
       break;
     default:
       break;
@@ -434,24 +384,24 @@ ReturnValue_t MgmLIS3MDLHandler::setOperatingMode(const uint8_t *commandData,
 }
 
 void MgmLIS3MDLHandler::fillCommandAndReplyMap() {
-  insertInCommandAndReplyMap(MGMLIS3MDL::READ_CONFIG_AND_DATA, 1, &dataset);
-  insertInCommandAndReplyMap(MGMLIS3MDL::READ_TEMPERATURE, 1);
-  insertInCommandAndReplyMap(MGMLIS3MDL::SETUP_MGM, 1);
-  insertInCommandAndReplyMap(MGMLIS3MDL::IDENTIFY_DEVICE, 1);
-  insertInCommandAndReplyMap(MGMLIS3MDL::TEMP_SENSOR_ENABLE, 1);
-  insertInCommandAndReplyMap(MGMLIS3MDL::ACCURACY_OP_MODE_SET, 1);
+  insertInCommandAndReplyMap(mgmLis3::READ_CONFIG_AND_DATA, 1, &dataset);
+  insertInCommandAndReplyMap(mgmLis3::READ_TEMPERATURE, 1);
+  insertInCommandAndReplyMap(mgmLis3::SETUP_MGM, 1);
+  insertInCommandAndReplyMap(mgmLis3::IDENTIFY_DEVICE, 1);
+  insertInCommandAndReplyMap(mgmLis3::TEMP_SENSOR_ENABLE, 1);
+  insertInCommandAndReplyMap(mgmLis3::ACCURACY_OP_MODE_SET, 1);
 }
 
 void MgmLIS3MDLHandler::setToGoToNormalMode(bool enable) { this->goToNormalMode = enable; }
 
 ReturnValue_t MgmLIS3MDLHandler::prepareCtrlRegisterWrite() {
-  commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1, true);
+  commandBuffer[0] = mgmLis3::writeCommand(mgmLis3::CTRL_REG1, true);
 
-  for (size_t i = 0; i < MGMLIS3MDL::NR_OF_CTRL_REGISTERS; i++) {
+  for (size_t i = 0; i < mgmLis3::NR_OF_CTRL_REGISTERS; i++) {
     commandBuffer[i + 1] = registers[i];
   }
   rawPacket = commandBuffer;
-  rawPacketLen = MGMLIS3MDL::NR_OF_CTRL_REGISTERS + 1;
+  rawPacketLen = mgmLis3::NR_OF_CTRL_REGISTERS + 1;
 
   // We dont have to check if this is working because we just did i
   return returnvalue::OK;
@@ -467,8 +417,8 @@ void MgmLIS3MDLHandler::modeChanged(void) { internalState = InternalState::STATE
 
 ReturnValue_t MgmLIS3MDLHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                          LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTHS, &mgmXYZ);
-  localDataPoolMap.emplace(MGMLIS3MDL::TEMPERATURE_CELCIUS, &temperature);
+  localDataPoolMap.emplace(mgmLis3::FIELD_STRENGTHS, &mgmXYZ);
+  localDataPoolMap.emplace(mgmLis3::TEMPERATURE_CELCIUS, &temperature);
   poolManager.subscribeForRegularPeriodicPacket({dataset.getSid(), false, 10.0});
   return returnvalue::OK;
 }

src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h

@@ -1,7 +1,8 @@
 #ifndef MISSION_DEVICES_MGMLIS3MDLHANDLER_H_
 #define MISSION_DEVICES_MGMLIS3MDLHANDLER_H_
 
-#include "devicedefinitions/MgmLIS3HandlerDefs.h"
+#include <fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h>
+
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "fsfw/globalfunctions/PeriodicOperationDivider.h"
 
@@ -66,7 +67,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
                                         LocalDataPoolManager &poolManager) override;
 
  private:
-  MGMLIS3MDL::MgmPrimaryDataset dataset;
+  mgmLis3::MgmPrimaryDataset dataset;
   // Length a single command SPI answer
   static const uint8_t SINGLE_COMMAND_ANSWER_LEN = 2;
 
@@ -74,7 +75,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
   // Single SPI command has 2 bytes, first for adress, second for content
   size_t singleComandSize = 2;
   // Has the size for all adresses of the lis3mdl + the continous write bit
-  uint8_t commandBuffer[MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1];
+  uint8_t commandBuffer[mgmLis3::NR_OF_DATA_AND_CFG_REGISTERS + 1];
 
   float absLimitX = 100;
   float absLimitY = 100;
@@ -85,7 +86,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
    * registers when we want to change something.
    * --> everytime we change set a register we have to save it
    */
-  uint8_t registers[MGMLIS3MDL::NR_OF_CTRL_REGISTERS];
+  uint8_t registers[mgmLis3::NR_OF_CTRL_REGISTERS];
 
   uint8_t statusRegister = 0;
   bool goToNormalMode = false;
@@ -107,35 +108,6 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
   /*------------------------------------------------------------------------*/
   /* Device specific commands and variables */
   /*------------------------------------------------------------------------*/
-  /**
-   * Sets the read bit for the command
-   * @param single command to set the read-bit at
-   * @param boolean to select a continuous read bit, default = false
-   */
-  uint8_t readCommand(uint8_t command, bool continuousCom = false);
-
-  /**
-   * Sets the write bit for the command
-   * @param single command to set the write-bit at
-   * @param boolean to select a continuous write bit, default = false
-   */
-  uint8_t writeCommand(uint8_t command, bool continuousCom = false);
-
-  /**
-   * This Method gets the full scale for the measurement range
-   * e.g.: +- 4 gauss. See p.25 datasheet.
-   *  @return The ReturnValue does not contain the sign of the value
-   */
-  MGMLIS3MDL::Sensitivies getSensitivity(uint8_t ctrlReg2);
-
-  /**
-   * The 16 bit value needs to be multiplied with a sensitivity factor
-   * which depends on the sensitivity configuration
-   *
-   * @param sens Configured sensitivity of the LIS3 device
-   * @return Multiplication factor to get the sensor value from raw data.
-   */
-  float getSensitivityFactor(MGMLIS3MDL::Sensitivies sens);
 
   /**
    * This Command detects the device ID

src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -63,21 +63,21 @@ ReturnValue_t MgmRM3100Handler::buildTransitionDeviceCommand(DeviceCommandId_t *
       return NOTHING_TO_SEND;
     }
     case (InternalState::CONFIGURE_CMM): {
-      *id = RM3100::CONFIGURE_CMM;
+      *id = mgmRm3100::CONFIGURE_CMM;
       break;
     }
     case (InternalState::READ_CMM): {
-      *id = RM3100::READ_CMM;
+      *id = mgmRm3100::READ_CMM;
       break;
     }
     case (InternalState::STATE_CONFIGURE_TMRC): {
-      commandBuffer[0] = RM3100::TMRC_DEFAULT_VALUE;
+      commandBuffer[0] = mgmRm3100::TMRC_DEFAULT_VALUE;
       commandLen = 1;
-      *id = RM3100::CONFIGURE_TMRC;
+      *id = mgmRm3100::CONFIGURE_TMRC;
       break;
     }
     case (InternalState::STATE_READ_TMRC): {
-      *id = RM3100::READ_TMRC;
+      *id = mgmRm3100::READ_TMRC;
       break;
     }
     default:
@@ -103,42 +103,42 @@ ReturnValue_t MgmRM3100Handler::buildCommandFromCommand(DeviceCommandId_t device
                                                         const uint8_t *commandData,
                                                         size_t commandDataLen) {
   switch (deviceCommand) {
-    case (RM3100::CONFIGURE_CMM): {
-      commandBuffer[0] = RM3100::CMM_REGISTER;
-      commandBuffer[1] = RM3100::CMM_VALUE;
+    case (mgmRm3100::CONFIGURE_CMM): {
+      commandBuffer[0] = mgmRm3100::CMM_REGISTER;
+      commandBuffer[1] = mgmRm3100::CMM_VALUE;
       rawPacket = commandBuffer;
       rawPacketLen = 2;
       break;
     }
-    case (RM3100::READ_CMM): {
-      commandBuffer[0] = RM3100::CMM_REGISTER | RM3100::READ_MASK;
+    case (mgmRm3100::READ_CMM): {
+      commandBuffer[0] = mgmRm3100::CMM_REGISTER | mgmRm3100::READ_MASK;
       commandBuffer[1] = 0;
       rawPacket = commandBuffer;
       rawPacketLen = 2;
       break;
     }
-    case (RM3100::CONFIGURE_TMRC): {
+    case (mgmRm3100::CONFIGURE_TMRC): {
       return handleTmrcConfigCommand(deviceCommand, commandData, commandDataLen);
     }
-    case (RM3100::READ_TMRC): {
-      commandBuffer[0] = RM3100::TMRC_REGISTER | RM3100::READ_MASK;
+    case (mgmRm3100::READ_TMRC): {
+      commandBuffer[0] = mgmRm3100::TMRC_REGISTER | mgmRm3100::READ_MASK;
       commandBuffer[1] = 0;
       rawPacket = commandBuffer;
       rawPacketLen = 2;
       break;
     }
-    case (RM3100::CONFIGURE_CYCLE_COUNT): {
+    case (mgmRm3100::CONFIGURE_CYCLE_COUNT): {
       return handleCycleCountConfigCommand(deviceCommand, commandData, commandDataLen);
     }
-    case (RM3100::READ_CYCLE_COUNT): {
-      commandBuffer[0] = RM3100::CYCLE_COUNT_START_REGISTER | RM3100::READ_MASK;
+    case (mgmRm3100::READ_CYCLE_COUNT): {
+      commandBuffer[0] = mgmRm3100::CYCLE_COUNT_START_REGISTER | mgmRm3100::READ_MASK;
       std::memset(commandBuffer + 1, 0, 6);
       rawPacket = commandBuffer;
       rawPacketLen = 7;
       break;
     }
-    case (RM3100::READ_DATA): {
-      commandBuffer[0] = RM3100::MEASUREMENT_REG_START | RM3100::READ_MASK;
+    case (mgmRm3100::READ_DATA): {
+      commandBuffer[0] = mgmRm3100::MEASUREMENT_REG_START | mgmRm3100::READ_MASK;
       std::memset(commandBuffer + 1, 0, 9);
       rawPacketLen = 10;
       break;
@@ -150,7 +150,7 @@ ReturnValue_t MgmRM3100Handler::buildCommandFromCommand(DeviceCommandId_t device
 }
 
 ReturnValue_t MgmRM3100Handler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
-  *id = RM3100::READ_DATA;
+  *id = mgmRm3100::READ_DATA;
   return buildCommandFromCommand(*id, nullptr, 0);
 }
 
@@ -165,16 +165,16 @@ ReturnValue_t MgmRM3100Handler::scanForReply(const uint8_t *start, size_t len,
 ReturnValue_t MgmRM3100Handler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
   ReturnValue_t result = returnvalue::OK;
   switch (id) {
-    case (RM3100::CONFIGURE_CMM):
-    case (RM3100::CONFIGURE_CYCLE_COUNT):
-    case (RM3100::CONFIGURE_TMRC): {
+    case (mgmRm3100::CONFIGURE_CMM):
+    case (mgmRm3100::CONFIGURE_CYCLE_COUNT):
+    case (mgmRm3100::CONFIGURE_TMRC): {
       // We can only check whether write was successful with read operation
       if (getMode() == _MODE_START_UP) {
         commandExecuted = true;
       }
       break;
     }
-    case (RM3100::READ_CMM): {
+    case (mgmRm3100::READ_CMM): {
       uint8_t cmmValue = packet[1];
       // We clear the seventh bit in any case
       // because this one is zero sometimes for some reason
@@ -188,7 +188,7 @@ ReturnValue_t MgmRM3100Handler::interpretDeviceReply(DeviceCommandId_t id, const
       }
       break;
     }
-    case (RM3100::READ_TMRC): {
+    case (mgmRm3100::READ_TMRC): {
       if (packet[1] == tmrcRegValue) {
         commandExecuted = true;
         // Reading TMRC was commanded. Trigger event to inform ground
@@ -202,7 +202,7 @@ ReturnValue_t MgmRM3100Handler::interpretDeviceReply(DeviceCommandId_t id, const
       }
       break;
     }
-    case (RM3100::READ_CYCLE_COUNT): {
+    case (mgmRm3100::READ_CYCLE_COUNT): {
       uint16_t cycleCountX = packet[1] << 8 | packet[2];
       uint16_t cycleCountY = packet[3] << 8 | packet[4];
       uint16_t cycleCountZ = packet[5] << 8 | packet[6];
@@ -217,7 +217,7 @@ ReturnValue_t MgmRM3100Handler::interpretDeviceReply(DeviceCommandId_t id, const
       }
       break;
     }
-    case (RM3100::READ_DATA): {
+    case (mgmRm3100::READ_DATA): {
       result = handleDataReadout(packet);
       break;
     }
@@ -244,7 +244,7 @@ ReturnValue_t MgmRM3100Handler::handleCycleCountConfigCommand(DeviceCommandId_t
     return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
   }
 
-  commandBuffer[0] = RM3100::CYCLE_COUNT_VALUE;
+  commandBuffer[0] = mgmRm3100::CYCLE_COUNT_VALUE;
   std::memcpy(commandBuffer + 1, &cycleCountRegValueX, 2);
   std::memcpy(commandBuffer + 3, &cycleCountRegValueY, 2);
   std::memcpy(commandBuffer + 5, &cycleCountRegValueZ, 2);
@@ -255,7 +255,7 @@ ReturnValue_t MgmRM3100Handler::handleCycleCountConfigCommand(DeviceCommandId_t
 
 ReturnValue_t MgmRM3100Handler::handleCycleCommand(bool oneCycleValue, const uint8_t *commandData,
                                                    size_t commandDataLen) {
-  RM3100::CycleCountCommand command(oneCycleValue);
+  mgmRm3100::CycleCountCommand command(oneCycleValue);
   ReturnValue_t result =
       command.deSerialize(&commandData, &commandDataLen, SerializeIF::Endianness::BIG);
   if (result != returnvalue::OK) {
@@ -284,7 +284,7 @@ ReturnValue_t MgmRM3100Handler::handleTmrcConfigCommand(DeviceCommandId_t device
     return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
   }
 
-  commandBuffer[0] = RM3100::TMRC_REGISTER;
+  commandBuffer[0] = mgmRm3100::TMRC_REGISTER;
   commandBuffer[1] = commandData[0];
   tmrcRegValue = commandData[0];
   rawPacketLen = 2;
@@ -293,23 +293,23 @@ ReturnValue_t MgmRM3100Handler::handleTmrcConfigCommand(DeviceCommandId_t device
 }
 
 void MgmRM3100Handler::fillCommandAndReplyMap() {
-  insertInCommandAndReplyMap(RM3100::CONFIGURE_CMM, 3);
-  insertInCommandAndReplyMap(RM3100::READ_CMM, 3);
+  insertInCommandAndReplyMap(mgmRm3100::CONFIGURE_CMM, 3);
+  insertInCommandAndReplyMap(mgmRm3100::READ_CMM, 3);
 
-  insertInCommandAndReplyMap(RM3100::CONFIGURE_TMRC, 3);
-  insertInCommandAndReplyMap(RM3100::READ_TMRC, 3);
+  insertInCommandAndReplyMap(mgmRm3100::CONFIGURE_TMRC, 3);
+  insertInCommandAndReplyMap(mgmRm3100::READ_TMRC, 3);
 
-  insertInCommandAndReplyMap(RM3100::CONFIGURE_CYCLE_COUNT, 3);
-  insertInCommandAndReplyMap(RM3100::READ_CYCLE_COUNT, 3);
+  insertInCommandAndReplyMap(mgmRm3100::CONFIGURE_CYCLE_COUNT, 3);
+  insertInCommandAndReplyMap(mgmRm3100::READ_CYCLE_COUNT, 3);
 
-  insertInCommandAndReplyMap(RM3100::READ_DATA, 3, &primaryDataset);
+  insertInCommandAndReplyMap(mgmRm3100::READ_DATA, 3, &primaryDataset);
 }
 
 void MgmRM3100Handler::modeChanged() { internalState = InternalState::NONE; }
 
 ReturnValue_t MgmRM3100Handler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                         LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(RM3100::FIELD_STRENGTHS, &mgmXYZ);
+  localDataPoolMap.emplace(mgmRm3100::FIELD_STRENGTHS, &mgmXYZ);
   poolManager.subscribeForRegularPeriodicPacket({primaryDataset.getSid(), false, 10.0});
   return returnvalue::OK;
 }

src/fsfw_hal/devicehandlers/MgmRM3100Handler.h

@@ -1,7 +1,8 @@
 #ifndef MISSION_DEVICES_MGMRM3100HANDLER_H_
 #define MISSION_DEVICES_MGMRM3100HANDLER_H_
 
-#include "devicedefinitions/MgmRM3100HandlerDefs.h"
+#include <fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h>
+
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "fsfw/globalfunctions/PeriodicOperationDivider.h"
 
@@ -69,19 +70,19 @@ class MgmRM3100Handler : public DeviceHandlerBase {
   };
   InternalState internalState = InternalState::NONE;
   bool commandExecuted = false;
-  RM3100::Rm3100PrimaryDataset primaryDataset;
+  mgmRm3100::Rm3100PrimaryDataset primaryDataset;
 
   uint8_t commandBuffer[10];
   uint8_t commandBufferLen = 0;
 
-  uint8_t cmmRegValue = RM3100::CMM_VALUE;
-  uint8_t tmrcRegValue = RM3100::TMRC_DEFAULT_VALUE;
-  uint16_t cycleCountRegValueX = RM3100::CYCLE_COUNT_VALUE;
-  uint16_t cycleCountRegValueY = RM3100::CYCLE_COUNT_VALUE;
-  uint16_t cycleCountRegValueZ = RM3100::CYCLE_COUNT_VALUE;
-  float scaleFactorX = 1.0 / RM3100::DEFAULT_GAIN;
-  float scaleFactorY = 1.0 / RM3100::DEFAULT_GAIN;
-  float scaleFactorZ = 1.0 / RM3100::DEFAULT_GAIN;
+  uint8_t cmmRegValue = mgmRm3100::CMM_VALUE;
+  uint8_t tmrcRegValue = mgmRm3100::TMRC_DEFAULT_VALUE;
+  uint16_t cycleCountRegValueX = mgmRm3100::CYCLE_COUNT_VALUE;
+  uint16_t cycleCountRegValueY = mgmRm3100::CYCLE_COUNT_VALUE;
+  uint16_t cycleCountRegValueZ = mgmRm3100::CYCLE_COUNT_VALUE;
+  float scaleFactorX = 1.0 / mgmRm3100::DEFAULT_GAIN;
+  float scaleFactorY = 1.0 / mgmRm3100::DEFAULT_GAIN;
+  float scaleFactorZ = 1.0 / mgmRm3100::DEFAULT_GAIN;
 
   bool goToNormalModeAtStartup = false;
   uint32_t transitionDelay;

src/fsfw_hal/devicehandlers/devicedefinitions/CMakeLists.txt

@@ -1 +1 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE gyroL3gHelpers.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE gyroL3gHelpers.cpp mgmLis3Helpers.cpp)

src/fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h

@@ -73,8 +73,10 @@ static constexpr uint8_t CTRL_REG_4_VAL = SET_BLE;
 /* Register 5 */
 static constexpr uint8_t SET_REBOOT_MEM = 1 << 7;
 static constexpr uint8_t SET_FIFO_ENB = 1 << 6;
+static constexpr uint8_t SET_OUT_SEL_1 = 1 << 1;
+static constexpr uint8_t SET_OUT_SEL_0 = 1 << 0;
 
-static constexpr uint8_t CTRL_REG_5_VAL = 0b00000000;
+static constexpr uint8_t CTRL_REG_5_VAL = SET_OUT_SEL_1 | SET_OUT_SEL_0;
 
 /* Possible range values in degrees per second (DPS). */
 static constexpr uint16_t RANGE_DPS_00 = 245;

src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.cpp

@@ -0,0 +1,52 @@
+#include "mgmLis3Helpers.h"
+
+uint8_t mgmLis3::readCommand(uint8_t command, bool continuousCom) {
+  command |= (1 << mgmLis3::RW_BIT);
+  if (continuousCom == true) {
+    command |= (1 << mgmLis3::MS_BIT);
+  }
+  return command;
+}
+
+uint8_t mgmLis3::writeCommand(uint8_t command, bool continuousCom) {
+  command &= ~(1 << mgmLis3::RW_BIT);
+  if (continuousCom == true) {
+    command |= (1 << mgmLis3::MS_BIT);
+  }
+  return command;
+}
+
+mgmLis3::Sensitivies mgmLis3::getSensitivity(uint8_t ctrlRegister2) {
+  bool fs0Set = ctrlRegister2 & (1 << mgmLis3::FSO);  // Checks if FS0 bit is set
+  bool fs1Set = ctrlRegister2 & (1 << mgmLis3::FS1);  // Checks if FS1 bit is set
+
+  if (fs0Set && fs1Set)
+    return mgmLis3::Sensitivies::GAUSS_16;
+  else if (!fs0Set && fs1Set)
+    return mgmLis3::Sensitivies::GAUSS_12;
+  else if (fs0Set && !fs1Set)
+    return mgmLis3::Sensitivies::GAUSS_8;
+  else
+    return mgmLis3::Sensitivies::GAUSS_4;
+}
+
+float mgmLis3::getSensitivityFactor(mgmLis3::Sensitivies sens) {
+  switch (sens) {
+    case (mgmLis3::GAUSS_4): {
+      return mgmLis3::FIELD_LSB_PER_GAUSS_4_SENS;
+    }
+    case (mgmLis3::GAUSS_8): {
+      return mgmLis3::FIELD_LSB_PER_GAUSS_8_SENS;
+    }
+    case (mgmLis3::GAUSS_12): {
+      return mgmLis3::FIELD_LSB_PER_GAUSS_12_SENS;
+    }
+    case (mgmLis3::GAUSS_16): {
+      return mgmLis3::FIELD_LSB_PER_GAUSS_16_SENS;
+    }
+    default: {
+      // Should never happen
+      return mgmLis3::FIELD_LSB_PER_GAUSS_4_SENS;
+    }
+  }
+}

src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h

@@ -7,13 +7,43 @@
 
 #include <cstdint>
 
-namespace MGMLIS3MDL {
+namespace mgmLis3 {
 
 enum Set { ON, OFF };
 enum OpMode { LOW, MEDIUM, HIGH, ULTRA };
 
 enum Sensitivies : uint8_t { GAUSS_4 = 4, GAUSS_8 = 8, GAUSS_12 = 12, GAUSS_16 = 16 };
 
+/**
+ * Sets the read bit for the command
+ * @param single command to set the read-bit at
+ * @param boolean to select a continuous read bit, default = false
+ */
+uint8_t readCommand(uint8_t command, bool continuousCom = false);
+
+/**
+ * Sets the write bit for the command
+ * @param single command to set the write-bit at
+ * @param boolean to select a continuous write bit, default = false
+ */
+uint8_t writeCommand(uint8_t command, bool continuousCom = false);
+
+/**
+ * This Method gets the full scale for the measurement range
+ * e.g.: +- 4 gauss. See p.25 datasheet.
+ *  @return The ReturnValue does not contain the sign of the value
+ */
+mgmLis3::Sensitivies getSensitivity(uint8_t ctrlReg2);
+
+/**
+ * The 16 bit value needs to be multiplied with a sensitivity factor
+ * which depends on the sensitivity configuration
+ *
+ * @param sens Configured sensitivity of the LIS3 device
+ * @return Multiplication factor to get the sensor value from raw data.
+ */
+float getSensitivityFactor(mgmLis3::Sensitivies sens);
+
 /* Actually 15, we just round up a bit */
 static constexpr size_t MAX_BUFFER_SIZE = 16;
 
@@ -154,6 +184,6 @@ class MgmPrimaryDataset : public StaticLocalDataSet<4> {
   lp_var_t<float> temperature = lp_var_t<float>(sid.objectId, TEMPERATURE_CELCIUS, this);
 };
 
-}  // namespace MGMLIS3MDL
+}  // namespace mgmLis3
 
 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_MGMLIS3HANDLERDEFS_H_ */

src/fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h

@@ -8,7 +8,7 @@
 
 #include <cstdint>
 
-namespace RM3100 {
+namespace mgmRm3100 {
 
 /* Actually 10, we round up a little bit */
 static constexpr size_t MAX_BUFFER_SIZE = 12;
@@ -115,6 +115,6 @@ class Rm3100PrimaryDataset : public StaticLocalDataSet<3> {
   lp_vec_t<float, 3> fieldStrengths = lp_vec_t<float, 3>(sid.objectId, FIELD_STRENGTHS, this);
 };
 
-}  // namespace RM3100
+}  // namespace mgmRm3100
 
 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERRM3100DEFINITIONS_H_ */

src/fsfw_hal/host/HostFilesystem.cpp

@@ -15,7 +15,8 @@ ReturnValue_t HostFilesystem::writeToFile(FileOpParams params, const uint8_t *da
     return returnvalue::FAILED;
   }
   path path(params.path());
-  if (not exists(path)) {
+  std::error_code e;
+  if (not exists(path, e)) {
     return HasFileSystemIF::FILE_DOES_NOT_EXIST;
   }
   // This is equivalent to "r+" mode, which is what we need here. Only using ::out would truncate
@@ -35,7 +36,8 @@ ReturnValue_t HostFilesystem::readFromFile(FileOpParams params, uint8_t **buffer
     return returnvalue::FAILED;
   }
   path path(params.path());
-  if (not exists(path)) {
+  std::error_code e;
+  if (not exists(path, e)) {
     return HasFileSystemIF::FILE_DOES_NOT_EXIST;
   }
   ifstream file(path);
@@ -59,7 +61,8 @@ ReturnValue_t HostFilesystem::createFile(FilesystemParams params, const uint8_t
     return returnvalue::FAILED;
   }
   path path(params.path);
-  if (exists(path)) {
+  std::error_code e;
+  if (exists(path, e)) {
     return HasFileSystemIF::FILE_ALREADY_EXISTS;
   }
   ofstream file(path);
@@ -74,7 +77,8 @@ ReturnValue_t HostFilesystem::removeFile(const char *path_, FileSystemArgsIF *ar
     return returnvalue::FAILED;
   }
   path path(path_);
-  if (not exists(path)) {
+  std::error_code e;
+  if (not exists(path, e)) {
     return HasFileSystemIF::FILE_DOES_NOT_EXIST;
   }
   if (remove(path, errorCode)) {
@@ -89,7 +93,8 @@ ReturnValue_t HostFilesystem::createDirectory(FilesystemParams params, bool crea
   }
   path dirPath(params.path);
 
-  if (exists(dirPath)) {
+  std::error_code e;
+  if (exists(dirPath, e)) {
     return HasFileSystemIF::DIRECTORY_ALREADY_EXISTS;
   }
 
@@ -110,7 +115,8 @@ ReturnValue_t HostFilesystem::removeDirectory(FilesystemParams params, bool dele
     return returnvalue::FAILED;
   }
   path dirPath(params.path);
-  if (not exists(dirPath)) {
+  std::error_code e;
+  if (not exists(dirPath, e)) {
     return HasFileSystemIF::DIRECTORY_DOES_NOT_EXIST;
   }
   if (is_regular_file(dirPath)) {
@@ -149,15 +155,18 @@ ReturnValue_t HostFilesystem::rename(const char *oldPath_, const char *newPath_,
 
 bool HostFilesystem::fileExists(FilesystemParams params) {
   path path(params.path);
-  return filesystem::exists(path);
+  std::error_code e;
+  return filesystem::exists(path, e);
 }
 
 ReturnValue_t HostFilesystem::truncateFile(FilesystemParams params) {
   path path(params.path);
-  if (not filesystem::exists(path)) {
+  std::error_code e;
+  if (not filesystem::exists(path, e)) {
     return FILE_DOES_NOT_EXIST;
   }
-  ofstream of(path);
+  // Specify truncation flug explicitely.
+  ofstream of(path, std::ios::out | std::ios::trunc);
   return returnvalue::OK;
 }
 

src/fsfw_hal/linux/CommandExecutor.cpp

@@ -17,7 +17,7 @@ ReturnValue_t CommandExecutor::load(std::string command, bool blocking, bool pri
     return COMMAND_PENDING;
   }
 
-  currentCmd = command;
+  currentCmd = std::move(command);
   this->blocking = blocking;
   this->printOutput = printOutput;
   if (state == States::IDLE) {

src/fsfw_hal/linux/i2c/I2cComIF.cpp

@@ -112,8 +112,9 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
     if (i2cCookie->errorCounter < 3) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "I2cComIF::sendMessage: Failed to send data to I2C "
-                    "device with error code "
-                 << errno << ". Error description: " << strerror(errno) << std::endl;
+                    "device from "
+                 << deviceFile << " with error code " << errno
+                 << ". Error description: " << strerror(errno) << std::endl;
 #endif
     }
     return returnvalue::FAILED;

src/fsfw_hal/linux/serial/SerialComIF.cpp

@@ -88,11 +88,11 @@ int SerialComIF::configureUartPort(SerialCookie* uartCookie) {
     return fd;
   }
 
-  uart::setParity(options, uartCookie->getParity());
+  serial::setParity(options, uartCookie->getParity());
   setStopBitOptions(&options, uartCookie);
   setDatasizeOptions(&options, uartCookie);
   setFixedOptions(&options);
-  uart::setMode(options, uartCookie->getUartMode());
+  serial::setMode(options, uartCookie->getUartMode());
   if (uartCookie->getInputShouldBeFlushed()) {
     tcflush(fd, TCIFLUSH);
   }
@@ -101,7 +101,7 @@ int SerialComIF::configureUartPort(SerialCookie* uartCookie) {
   options.c_cc[VTIME] = 0;
   options.c_cc[VMIN] = 0;
 
-  uart::setBaudrate(options, uartCookie->getBaudrate());
+  serial::setBaudrate(options, uartCookie->getBaudrate());
 
   /* Save option settings */
   if (tcsetattr(fd, TCSANOW, &options) != 0) {

src/fsfw_hal/linux/serial/helper.cpp

@@ -3,7 +3,7 @@
 
 #include "fsfw/serviceinterface.h"
 
-void uart::setMode(struct termios& options, UartModes mode) {
+void serial::setMode(struct termios& options, UartModes mode) {
   if (mode == UartModes::NON_CANONICAL) {
     /* Disable canonical mode */
     options.c_lflag &= ~ICANON;
@@ -12,7 +12,7 @@ void uart::setMode(struct termios& options, UartModes mode) {
   }
 }
 
-void uart::setBaudrate(struct termios& options, UartBaudRate baud) {
+void serial::setBaudrate(struct termios& options, UartBaudRate baud) {
   switch (baud) {
     case UartBaudRate::RATE_50:
       cfsetspeed(&options, B50);
@@ -114,7 +114,7 @@ void uart::setBaudrate(struct termios& options, UartBaudRate baud) {
   }
 }
 
-void uart::setBitsPerWord(struct termios& options, BitsPerWord bits) {
+void serial::setBitsPerWord(struct termios& options, BitsPerWord bits) {
   options.c_cflag &= ~CSIZE;  // Clear all the size bits
   if (bits == BitsPerWord::BITS_5) {
     options.c_cflag |= CS5;
@@ -127,11 +127,11 @@ void uart::setBitsPerWord(struct termios& options, BitsPerWord bits) {
   }
 }
 
-void uart::enableRead(struct termios& options) { options.c_cflag |= CREAD; }
+void serial::enableRead(struct termios& options) { options.c_cflag |= CREAD; }
 
-void uart::ignoreCtrlLines(struct termios& options) { options.c_cflag |= CLOCAL; }
+void serial::ignoreCtrlLines(struct termios& options) { options.c_cflag |= CLOCAL; }
 
-void uart::setParity(struct termios& options, Parity parity) {
+void serial::setParity(struct termios& options, Parity parity) {
   /* Clear parity bit */
   options.c_cflag &= ~PARENB;
   switch (parity) {
@@ -148,11 +148,11 @@ void uart::setParity(struct termios& options, Parity parity) {
   }
 }
 
-int uart::readCountersAndErrors(int serialPort, serial_icounter_struct& icounter) {
+int serial::readCountersAndErrors(int serialPort, serial_icounter_struct& icounter) {
   return ioctl(serialPort, TIOCGICOUNT, &icounter);
 }
 
-void uart::setStopbits(struct termios& options, StopBits bits) {
+void serial::setStopbits(struct termios& options, StopBits bits) {
   if (bits == StopBits::TWO_STOP_BITS) {
     // Use two stop bits
     options.c_cflag |= CSTOPB;
@@ -161,3 +161,7 @@ void uart::setStopbits(struct termios& options, StopBits bits) {
     options.c_cflag &= ~CSTOPB;
   }
 }
+
+void serial::flushRxBuf(int fd) { tcflush(fd, TCIFLUSH); }
+
+void serial::flushTxRxBuf(int fd) { tcflush(fd, TCIOFLUSH); }

src/fsfw_hal/linux/serial/helper.h

@@ -45,7 +45,7 @@ enum class UartBaudRate {
   RATE_4000000
 };
 
-namespace uart {
+namespace serial {
 
 void setMode(struct termios& options, UartModes mode);
 /**
@@ -64,8 +64,11 @@ void setParity(struct termios& options, Parity parity);
 
 void ignoreCtrlLines(struct termios& options);
 
+void flushRxBuf(int fd);
+void flushTxRxBuf(int fd);
+
 int readCountersAndErrors(int serialPort, serial_icounter_struct& icounter);
 
-}  // namespace uart
+}  // namespace serial
 
 #endif /* FSFW_HAL_LINUX_UART_HELPER_H_ */

src/fsfw_hal/linux/spi/SpiComIF.cpp

@@ -173,7 +173,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
   int fileDescriptor = 0;
   UnixFileGuard fileHelper(dev, fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
   if (fileHelper.getOpenResult() != returnvalue::OK) {
-    return OPENING_FILE_FAILED;
+    return spi::OPENING_FILE_FAILED;
   }
   spi::SpiModes spiMode = spi::SpiModes::MODE_0;
   uint32_t spiSpeed = 0;
@@ -234,7 +234,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
     if (retval < 0) {
       spiCookie->setTransferSize(0);
       utility::handleIoctlError("SpiComIF::sendMessage: ioctl error.");
-      result = FULL_DUPLEX_TRANSFER_FAILED;
+      result = spi::FULL_DUPLEX_TRANSFER_FAILED;
     }
 #if FSFW_HAL_SPI_WIRETAPPING == 1
     performSpiWiretapping(spiCookie);
@@ -250,7 +250,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
       sif::printWarning("SpiComIF::sendMessage: Half-Duplex write operation failed!\n");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
-      result = HALF_DUPLEX_TRANSFER_FAILED;
+      result = spi::HALF_DUPLEX_TRANSFER_FAILED;
     }
   }
 
@@ -287,7 +287,7 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
   int fileDescriptor = 0;
   UnixFileGuard fileHelper(dev, fileDescriptor, O_RDWR, "SpiComIF::requestReceiveMessage");
   if (fileHelper.getOpenResult() != returnvalue::OK) {
-    return OPENING_FILE_FAILED;
+    return spi::OPENING_FILE_FAILED;
   }
 
   uint8_t* rxBuf = nullptr;
@@ -327,7 +327,7 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
     sif::printWarning("SpiComIF::sendMessage: Half-Duplex read operation failed!\n");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
-    result = HALF_DUPLEX_TRANSFER_FAILED;
+    result = spi::HALF_DUPLEX_TRANSFER_FAILED;
   }
 
   if (gpioId != gpio::NO_GPIO and not csLockManual) {

src/fsfw_hal/linux/spi/SpiComIF.h

@@ -22,15 +22,6 @@ class SpiCookie;
  */
 class SpiComIF : public DeviceCommunicationIF, public SystemObject {
  public:
-  static constexpr uint8_t spiRetvalId = CLASS_ID::HAL_SPI;
-  static constexpr ReturnValue_t OPENING_FILE_FAILED = returnvalue::makeCode(spiRetvalId, 0);
-  /* Full duplex (ioctl) transfer failure */
-  static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED =
-      returnvalue::makeCode(spiRetvalId, 1);
-  /* Half duplex (read/write) transfer failure */
-  static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
-      returnvalue::makeCode(spiRetvalId, 2);
-
   SpiComIF(object_id_t objectId, std::string devname, GpioIF& gpioComIF);
 
   ReturnValue_t initializeInterface(CookieIF* cookie) override;

src/fsfw_hal/linux/uio/UioMapper.cpp

@@ -36,7 +36,7 @@ UioMapper::~UioMapper() {}
 
 ReturnValue_t UioMapper::getMappedAdress(uint32_t** address, Permissions permissions) {
   ReturnValue_t result = returnvalue::OK;
-  int fd = open(uioFile.c_str(), O_RDWR);
+  int fd = open(uioFile.c_str(), O_RDWR | O_SYNC);
   if (fd < 1) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "UioMapper::getMappedAdress: Invalid UIO device file " << uioFile << std::endl;

src/fsfw_hal/stm32h7/spi/SpiComIF.cpp

@@ -357,13 +357,13 @@ ReturnValue_t SpiComIF::halErrorHandler(HAL_StatusTypeDef status, spi::TransferM
   sif::printWarning("SpiComIF::handle%sSendOperation: HAL error %d occured\n", modeString, status);
   switch (status) {
     case (HAL_BUSY): {
-      return spi::HAL_BUSY_RETVAL;
+      return spi::BUSY;
     }
     case (HAL_ERROR): {
-      return spi::HAL_ERROR_RETVAL;
+      return spi::GENERIC_ERROR;
     }
     case (HAL_TIMEOUT): {
-      return spi::HAL_TIMEOUT_RETVAL;
+      return spi::TIMEOUT;
     }
     default: {
       return returnvalue::FAILED;

unittests/CMakeLists.txt

@@ -13,6 +13,7 @@ add_subdirectory(util)
 add_subdirectory(container)
 add_subdirectory(osal)
 add_subdirectory(pus)
+add_subdirectory(subsystem)
 add_subdirectory(serialize)
 add_subdirectory(datapoollocal)
 add_subdirectory(storagemanager)