WIP

CHANGELOG.md

@@ -8,71 +8,24 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-## Fixes
+# [v6.0.0]
-
-- 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
-
-## Changed
-- 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
-
-## Added
-
-- `EventManager`: Add function to print all listeners.
-
-## Changed
-
-- `EventManager`: Queue depth is configurable now
-
-# [v6.0.0] 2023-02-10
 
 ## Fixes
 
-- 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
   seconds instead of uptime.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/726
 - 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
-- 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
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/710/files
 - 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
@@ -82,41 +35,9 @@ 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
 
-- Empty constructor for `CdsShortTimeStamper` which does not do an object manager registration.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/730
 - `Service9TimeManagement`: Add `DUMP_TIME` (129) subservice.
 - `TcpTmTcServer`: Allow setting the `SO_REUSEADDR` and `SO_REUSEPORT`
   option on the TCP server. CTOR prototype has changed and expects an explicit
@@ -128,36 +49,13 @@ 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/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
-  so they can be used without template specification.
+  to 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
@@ -187,41 +85,18 @@ 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
-- Generic TMTC Bridge Update
+- Move some generic `StorageManagerIF` implementations from `LocalPool` to
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/734
+  interface itself so it can be re-used more easily. Also add new
-- comment tweak to event parser can read everything
+  abstract function `bool hasDataAtId(store_address_t storeId) const`.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/732
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/685
-- 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
 
@@ -241,7 +116,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
 
-# [v5.0.0] 2022-07-25
+# [v5.0.0] 25.07.2022
 
 ## Changes
 

CMakeLists.txt

@@ -13,7 +13,7 @@ list(APPEND CMAKE_MODULE_PATH
 # Version file handling  #
 # ##############################################################################
 
-set(FSFW_VERSION_IF_GIT_FAILS 6)
+set(FSFW_VERSION_IF_GIT_FAILS 5)
 set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
 set(FSFW_REVISION_IF_GIT_FAILS 0)
 
@@ -79,7 +79,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}.35.14
+    ${FSFW_ETL_LIB_MAJOR_VERSION}.28.0
     CACHE STRING "ETL library exact version requirement")
 set(FSFW_ETL_LINK_TARGET etl::etl)
 
@@ -165,7 +165,7 @@ if(FSFW_BUILD_TESTS)
   if(NOT Catch2_FOUND)
     message(
       STATUS
-        "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent."
+        "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent"
     )
     include(FetchContent)
 
@@ -229,8 +229,8 @@ find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
   message(
     STATUS
-      "${MSG_PREFIX} ETL installation not found. Downloading ETL with FetchContent."
+      "${MSG_PREFIX} No ETL installation was found with find_package. Installing and providing "
-  )
+      "etl with FindPackage")
   include(FetchContent)
 
   FetchContent_Declare(
@@ -480,7 +480,46 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-  set(FSFW_WARNING_FLAGS -Wall -Wno-gnu-anonymous-struct)
+  set(FSFW_WARNING_FLAGS 
+  -Weverything 
+
+  -Wno-gnu-anonymous-struct 
+  -Wno-c++98-compat
+  -Wno-c++98-compat-pedantic
+  -Wno-covered-switch-default
+  -Wno-padded 
+  -Wno-documentation
+  -Wno-weak-vtables
+  -Wno-c++98-c++11-compat-binary-literal
+  -Wno-documentation-unknown-command
+  -Wno-reserved-macro-identifier
+  -Wno-global-constructors
+  -Wno-reserved-identifier
+  -Wno-switch-enum
+
+  -Werror
+  #WTH?
+  -Wno-ctad-maybe-unsupported
+  #WIP
+  -Wno-undefined-func-template
+  -Wno-suggest-destructor-override
+  -Wno-suggest-override
+  -Wno-inconsistent-missing-destructor-override
+  -Wno-extra-semi
+  #could be useful:
+  -Wno-sign-conversion
+  -Wno-implicit-int-conversion
+  -Wno-shorten-64-to-32
+  -Wno-double-promotion
+  -Wno-float-conversion
+  -Wno-implicit-int-float-conversion
+  -Wno-implicit-float-conversion
+  -Wno-shadow-field-in-constructor
+  -Wno-shadow-field
+  -Wno-shadow
+  -Wno-unused-parameter
+
+  )
 endif()
 
 # Required include paths to compile the FSFW

automation/Jenkinsfile

@@ -14,7 +14,7 @@ pipeline {
         }
     }
     stages {
-        stage('x64-linux-clang-host') {
+        stage('Host-clang') {
             steps {
                 sh 'rm -rf $BUILDDIR_HOST'
 
@@ -25,7 +25,7 @@ pipeline {
                 }
             }
         }
-        stage('x64-linux-gcc') {
+        stage('Linux-gcc') {
             steps {
                 sh 'rm -rf $BUILDDIR_LINUX'
 
@@ -37,7 +37,7 @@ pipeline {
                 }
             }
         }
-        stage('x64-FreeRTOS-gcc') {
+        stage('FreeRTOS-gcc') {
             steps {
                 sh 'rm -rf $BUILDDIR_FREERTOS'
 
@@ -49,23 +49,23 @@ pipeline {
                 }
             }
         }
-        stage('aarch64-rtems6-gcc') {
+        stage('rtems-gcc') {
             steps {
                 sh 'rm -rf $BUILDDIR_RTEMS'
 
                 dir(BUILDDIR_RTEMS) {
-                    sh 'cmake -DFSFW_OSAL=rtems -DFSFW_BUILD_TESTS=ON -DFSFW_TESTS_GEN_COV=OFF -DFSFW_CICD_BUILD=ON -DCMAKE_TOOLCHAIN_FILE=../cmake/aarch64-rtems6-gcc.cmake ..'
+                    sh 'cmake -DFSFW_OSAL=rtems -DFSFW_BUILD_TESTS=ON -DFSFW_TESTS_GEN_COV=OFF -DFSFW_CICD_BUILD=ON -DCMAKE_TOOLCHAIN_FILE=../unittests/testcfg/rtems/cmake/aarch64-rtems6-toolchain.cmake ..'
                     sh 'cmake --build . -j4'
                     sh 'qemu-system-aarch64 -no-reboot -nographic -serial mon:stdio -semihosting -machine virt,gic-version=3 -cpu cortex-a72 -m 4000  -kernel fsfw-tests'
                 }
             }
         }
-        stage('x64-windows-msvc-host') {
+        stage('Host-msvc') {
             steps {
                 sh 'rm -rf $BUILDDIR_WIN'
 
                 dir(BUILDDIR_WIN) {
-                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_TESTS_GEN_COV=OFF -DFSFW_CICD_BUILD=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=../cmake/x64-windows-msvc.cmake -GNinja ..'
+                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_TESTS_GEN_COV=OFF -DFSFW_CICD_BUILD=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=../unittests/testcfg/windows/cmake/x64-windows-toolchain.cmake -GNinja ..'
                     sh 'cmake --build . -j4'
                     sh 'wine64 fsfw-tests.exe'
                 }

scripts/check_release.py

@@ -1,110 +0,0 @@
-#! /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/cfdp/handler/UserBase.h

@@ -68,6 +68,7 @@ class UserBase {
 
  public:
   explicit UserBase(HasFileSystemIF& vfs);
+  virtual ~UserBase() = default;
 
   virtual void transactionIndication(const TransactionId& id) = 0;
   virtual void eofSentIndication(const TransactionId& id) = 0;

src/fsfw/cfdp/helpers.cpp

@@ -1,6 +1,6 @@
 #include "helpers.h"
 
-const char* COND_CODE_STRINGS[14] = {"Unknown",
+static const char* COND_CODE_STRINGS[14] = {"Unknown",
                                      "No Error",
                                      "Positive ACK Limit Reached",
                                      "Keep Alive Limit Reached",

src/fsfw/container/BinaryTree.h

@@ -8,7 +8,7 @@
 template <typename Tp>
 class BinaryNode {
  public:
-  BinaryNode(Tp* setValue) : value(setValue), left(NULL), right(NULL), parent(NULL) {}
+  BinaryNode(Tp* setValue) : value(setValue), left(nullptr), right(nullptr), parent(nullptr) {}
   Tp* value;
   BinaryNode* left;
   BinaryNode* right;
@@ -23,31 +23,31 @@ class ExplicitNodeIterator {
   typedef Tp value_type;
   typedef Tp* pointer;
   typedef Tp& reference;
-  ExplicitNodeIterator() : element(NULL) {}
+  ExplicitNodeIterator() : element(nullptr) {}
   ExplicitNodeIterator(_Node* node) : element(node) {}
   BinaryNode<Tp>* element;
   _Self up() { return _Self(element->parent); }
   _Self left() {
-    if (element != NULL) {
+    if (element != nullptr) {
       return _Self(element->left);
     } else {
-      return _Self(NULL);
+      return _Self(nullptr);
     }
   }
   _Self right() {
-    if (element != NULL) {
+    if (element != nullptr) {
       return _Self(element->right);
     } else {
-      return _Self(NULL);
+      return _Self(nullptr);
     }
   }
   bool operator==(const _Self& __x) const { return element == __x.element; }
   bool operator!=(const _Self& __x) const { return element != __x.element; }
   pointer operator->() const {
-    if (element != NULL) {
+    if (element != nullptr) {
       return element->value;
     } else {
-      return NULL;
+      return nullptr;
     }
   }
   pointer operator*() const { return this->operator->(); }
@@ -62,13 +62,13 @@ class BinaryTree {
   typedef ExplicitNodeIterator<Tp> iterator;
   typedef BinaryNode<Tp> Node;
   typedef std::pair<iterator, iterator> children;
-  BinaryTree() : rootNode(NULL) {}
+  BinaryTree() : rootNode(nullptr) {}
   BinaryTree(Node* rootNode) : rootNode(rootNode) {}
   iterator begin() const { return iterator(rootNode); }
-  static iterator end() { return iterator(NULL); }
+  static iterator end() { return iterator(nullptr); }
   iterator insert(bool insertLeft, iterator parentNode, Node* newNode) {
     newNode->parent = parentNode.element;
-    if (parentNode.element != NULL) {
+    if (parentNode.element != nullptr) {
       if (insertLeft) {
         parentNode.element->left = newNode;
       } else {
@@ -84,13 +84,13 @@ class BinaryTree {
   children erase(iterator node) {
     if (node.element == rootNode) {
       // We're root node
-      rootNode = NULL;
+      rootNode = nullptr;
     } else {
       // Delete parent's reference
       if (node.up().left() == node) {
-        node.up().element->left = NULL;
+        node.up().element->left = nullptr;
       } else {
-        node.up().element->right = NULL;
+        node.up().element->right = nullptr;
       }
     }
     return children(node.element->left, node.element->right);

src/fsfw/container/FixedArrayList.h

@@ -12,7 +12,6 @@ template <typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList : public ArrayList<T, count_t> {
   static_assert(MAX_SIZE <= std::numeric_limits<count_t>::max(),
                 "count_t is not large enough to hold MAX_SIZE");
-  static_assert(MAX_SIZE > 0, "MAX_SIZE is 0");
 
  private:
   T data[MAX_SIZE];

src/fsfw/container/PlacementFactory.h

@@ -61,7 +61,7 @@ class PlacementFactory {
     // Need to call destructor first, in case something was allocated by the object (shouldn't do
     // that, however).
     thisElement->~T();
-    uint8_t* pointer = (uint8_t*)(thisElement);
+    uint8_t* pointer = static_cast<uint8_t*>(thisElement);
     return dataBackend->deleteData(pointer, sizeof(T));
   }
 

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -286,7 +286,6 @@ ReturnValue_t LocalDataPoolManager::addUpdateToStore(HousekeepingSnapshot& updat
   result = updatePacket.serialize(&storePtr, &serializedSize, updatePacketSize,
                                   SerializeIF::Endianness::MACHINE);
   return result;
-  ;
 }
 
 void LocalDataPoolManager::handleChangeResetLogic(DataType type, DataId dataId,

src/fsfw/devicehandlers/ChildHandlerBase.cpp

@@ -27,7 +27,7 @@ ReturnValue_t ChildHandlerBase::initialize() {
 
   if (parentId != objects::NO_OBJECT) {
     SubsystemBase* parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
-    if (parent == NULL) {
+    if (parent == nullptr) {
       return returnvalue::FAILED;
     }
     parentQueue = parent->getCommandQueue();

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -934,19 +934,14 @@ DeviceHandlerIF::CommunicationAction DeviceHandlerBase::getComAction() {
   switch (pstStep) {
     case 0:
       return CommunicationAction::PERFORM_OPERATION;
-      break;
     case 1:
       return CommunicationAction::SEND_WRITE;
-      break;
     case 2:
       return CommunicationAction::GET_WRITE;
-      break;
     case 3:
       return CommunicationAction::SEND_READ;
-      break;
     case 4:
       return CommunicationAction::GET_READ;
-      break;
     default:
       break;
   }
@@ -962,7 +957,7 @@ void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
     replyReturnvalueToCommand(result, RAW_COMMAND_ID);
     storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
   } else {
-    cookieInfo.pendingCommand = deviceCommandMap.find((DeviceCommandId_t)RAW_COMMAND_ID);
+    cookieInfo.pendingCommand = deviceCommandMap.find(static_cast<DeviceCommandId_t>(RAW_COMMAND_ID));
     cookieInfo.pendingCommand->second.isExecuting = true;
     cookieInfo.state = COOKIE_WRITE_READY;
   }

src/fsfw/devicehandlers/DeviceHandlerMessage.cpp

@@ -72,7 +72,7 @@ void DeviceHandlerMessage::clear(CommandMessage* message) {
         ipcStore->deleteData(getStoreAddress(message));
       }
     }
-      /* NO BREAK falls through*/
+      [[fallthrough]];
     case CMD_SWITCH_ADDRESS:
     case CMD_WIRETAPPING:
       message->setCommand(CommandMessage::CMD_NONE);

src/fsfw/events/EventManager.cpp

@@ -15,12 +15,11 @@ const LocalPool::LocalPoolConfig EventManager::poolConfig = {
     {fsfwconfig::FSFW_EVENTMGMT_EVENTIDMATCHERS, sizeof(EventIdRangeMatcher)},
     {fsfwconfig::FSFW_EVENTMGMR_RANGEMATCHERS, sizeof(ReporterRangeMatcher)}};
 
-EventManager::EventManager(object_id_t setObjectId, uint32_t eventQueueDepth)
+EventManager::EventManager(object_id_t setObjectId)
     : 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,
-  eventReportQueue = QueueFactory::instance()->createMessageQueue(
+                                                                  EventMessage::EVENT_MESSAGE_SIZE);
-      eventQueueDepth, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
 }
 
 EventManager::~EventManager() {
@@ -48,20 +47,9 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {
 
 void EventManager::notifyListeners(EventMessage* message) {
   lockMutex();
-  for (auto& listener : listenerList) {
+  for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
-    if (listener.second.match(message)) {
+    if (iter->second.match(message)) {
-      ReturnValue_t result =
+      MessageQueueSenderIF::sendMessage(iter->first, message, message->getSender());
-          MessageQueueSenderIF::sendMessage(listener.first, message, message->getSender());
-      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;
-#else
-        sif::printError("Sending message to listener 0x%08x failed with result %04x\n",
-                        listener.first, result);
-#endif
-      }
     }
   }
   unlockMutex();
@@ -212,19 +200,4 @@ void EventManager::printUtility(sif::OutputTypes printType, EventMessage* messag
   }
 }
 
-void EventManager::printListeners() {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "Event manager listener MQ IDs:" << std::setfill('0') << std::hex << std::endl;
-  for (auto& listener : listenerList) {
-    sif::info << "0x" << std::setw(8) << listener.first << std::endl;
-  }
-  sif::info << std::dec << std::setfill(' ');
-#else
-  sif::printInfo("Event manager listener MQ IDs:\n");
-  for (auto& listener : listenerList) {
-    sif::printInfo("0x%08x\n", listener.first);
-  }
-#endif
-}
-
 #endif /* FSFW_OBJ_EVENT_TRANSLATION == 1 */

src/fsfw/events/EventManager.h

@@ -21,8 +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;
 
-  EventManager(object_id_t setObjectId, uint32_t eventQueueDepth);
+  EventManager(object_id_t setObjectId);
   virtual ~EventManager();
 
   void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
@@ -45,9 +46,6 @@ class EventManager : public EventManagerIF, public ExecutableObjectIF, public Sy
                                           bool reporterInverted = false) override;
   ReturnValue_t performOperation(uint8_t opCode) override;
 
-  void printListeners();
-
-
  protected:
   MessageQueueIF* eventReportQueue = nullptr;
 

src/fsfw/events/fwSubsystemIdRanges.h

@@ -10,7 +10,7 @@ enum : uint8_t {
   CDH = 28,
   TCS_1 = 59,
   PCDU_1 = 42,
-  POWER_SWITCH_IF = 43,
+  PCDU_2 = 43,
   HEATER = 50,
   T_SENSORS = 52,
   FDIR = 70,
@@ -33,7 +33,6 @@ enum : uint8_t {
   PUS_SERVICE_23 = 103,
   MGM_LIS3MDL = 106,
   MGM_RM3100 = 107,
-  CFDP = 108,
 
   FW_SUBSYSTEM_ID_RANGE
 };

src/fsfw/health/HasHealthIF.h

@@ -16,24 +16,26 @@ class HasHealthIF {
   };
 
   static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
-  static constexpr ReturnValue_t OBJECT_NOT_HEALTHY = returnvalue::makeCode(INTERFACE_ID, 1);
+  static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
-  static constexpr ReturnValue_t INVALID_HEALTH_STATE = returnvalue::makeCode(INTERFACE_ID, 2);
+  static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
-  static constexpr ReturnValue_t IS_EXTERNALLY_CONTROLLED = returnvalue::makeCode(INTERFACE_ID, 3);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
-  //! P1: New Health, P2: Old Health
   static const Event HEALTH_INFO = MAKE_EVENT(6, severity::INFO);
   static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, severity::INFO);
   static const Event CHILD_PROBLEMS = MAKE_EVENT(8, severity::LOW);
-  //! Assembly overwrites health information of children to keep satellite alive.
+  static const Event OVERWRITING_HEALTH =
-  static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, severity::LOW);
+      MAKE_EVENT(9, severity::LOW);  //!< Assembly overwrites health information of children to keep
-  //! Someone starts a recovery of a component (typically power-cycle). No parameters.
+                                     //!< satellite alive.
-  static const Event TRYING_RECOVERY = MAKE_EVENT(10, severity::MEDIUM);
+  static const Event TRYING_RECOVERY =
-  //! Recovery is ongoing. Comes twice during recovery.
+      MAKE_EVENT(10, severity::MEDIUM);  //!< Someone starts a recovery of a component (typically
-  //! P1: 0 for the first, 1 for the second event. P2: 0
+                                         //!< power-cycle). No parameters.
-  static const Event RECOVERY_STEP = MAKE_EVENT(11, severity::MEDIUM);
+  static const Event RECOVERY_STEP =
-  //! Recovery was completed. Not necessarily successful. No parameters.
+      MAKE_EVENT(11, severity::MEDIUM);  //!< Recovery is ongoing. Comes twice during recovery. P1:
-  static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM);
+                                         //!< 0 for the first, 1 for the second event. P2: 0
+  static const Event RECOVERY_DONE = MAKE_EVENT(
+      12,
+      severity::MEDIUM);  //!< Recovery was completed. Not necessarily successful. No parameters.
+
   virtual ~HasHealthIF() {}
 
   virtual MessageQueueId_t getCommandQueue() const = 0;

src/fsfw/health/HealthTable.h

@@ -8,8 +8,6 @@
 #include "HealthTableIF.h"
 
 class HealthTable : public HealthTableIF, public SystemObject {
-  friend class CServiceHealthCommanding;
-
  public:
   explicit HealthTable(object_id_t objectid);
   ~HealthTable() override;

src/fsfw/ipc/CommandMessage.h

@@ -48,7 +48,7 @@ class CommandMessage : public MessageQueueMessage, public CommandMessageIF {
   /**
    * @brief 	Default Destructor
    */
-  virtual ~CommandMessage() {}
+  ~CommandMessage() override {}
 
   /**
    * Read the DeviceHandlerCommand_t that is stored in the message,

src/fsfw/ipc/CommandMessageIF.h

@@ -37,7 +37,7 @@ class CommandMessageIF {
   //! par1 should contain the error code
   static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID(2);
 
-  virtual ~CommandMessageIF(){};
+  virtual ~CommandMessageIF() = default;
 
   /**
    * A command message shall have a uint16_t command ID field.

src/fsfw/ipc/definitions.h

@@ -5,7 +5,7 @@
 #include <fsfw/objectmanager/frameworkObjects.h>
 
 struct MqArgs {
-  MqArgs(){};
+  MqArgs(){}
   MqArgs(object_id_t objectId, void* args = nullptr) : objectId(objectId), args(args) {}
   object_id_t objectId = objects::NO_OBJECT;
   void* args = nullptr;

src/fsfw/modes/ModeMessage.cpp

@@ -24,19 +24,3 @@ void ModeMessage::setCantReachMode(CommandMessage* message, ReturnValue_t reason
   message->setParameter(reason);
   message->setParameter2(0);
 }
-
-void ModeMessage::setModeAnnounceMessage(CommandMessage& message, bool recursive) {
-  Command_t cmd;
-  if (recursive) {
-    cmd = CMD_MODE_ANNOUNCE_RECURSIVELY;
-  } else {
-    cmd = CMD_MODE_ANNOUNCE;
-  }
-  message.setCommand(cmd);
-}
-
-void ModeMessage::setCmdModeMessage(CommandMessage& message, Mode_t mode, Submode_t submode) {
-  setModeMessage(&message, CMD_MODE_COMMAND, mode, submode);
-}
-
-void ModeMessage::setModeReadMessage(CommandMessage& message) { message.setCommand(CMD_MODE_READ); }

src/fsfw/modes/ModeMessage.h

@@ -45,9 +45,6 @@ class ModeMessage {
 
   static void setModeMessage(CommandMessage* message, Command_t command, Mode_t mode,
                              Submode_t submode);
-  static void setCmdModeMessage(CommandMessage& message, Mode_t mode, Submode_t submode);
-  static void setModeAnnounceMessage(CommandMessage& message, bool recursive);
-  static void setModeReadMessage(CommandMessage& message);
   static void setCantReachMode(CommandMessage* message, ReturnValue_t reason);
   static void clear(CommandMessage* message);
 };

src/fsfw/objectmanager/ObjectManagerIF.h

@@ -40,7 +40,7 @@ class ObjectManagerIF {
   /**
    * @brief	This is the empty virtual destructor as requested by C++ interfaces.
    */
-  virtual ~ObjectManagerIF(void){};
+  virtual ~ObjectManagerIF(void){}
   /**
    * @brief	With this call, new objects are inserted to the list.
    * @details	The implementation shall return an error code in case the

src/fsfw/objectmanager/SystemObject.h

@@ -45,7 +45,7 @@ class SystemObject : public SystemObjectIF {
   /**
    * @brief	On destruction, the object removes itself from the list.
    */
-  virtual ~SystemObject();
+  ~SystemObject() override;
   object_id_t getObjectId() const override;
   virtual ReturnValue_t initialize() override;
   virtual ReturnValue_t checkObjectConnections() override;

src/fsfw/objectmanager/SystemObjectIF.h

@@ -36,7 +36,7 @@ class SystemObjectIF : public EventReportingProxyIF {
   /**
    * The empty virtual destructor as required for C++ interfaces.
    */
-  virtual ~SystemObjectIF() {}
+  ~SystemObjectIF() override {}
   /**
    * @brief   Initializes the object.
    * There are initialization steps which can also be done in the constructor.

src/fsfw/osal/CMakeLists.txt

@@ -18,10 +18,7 @@ elseif(FSFW_OSAL MATCHES "host")
   endif()
   set(FSFW_OSAL_HOST 1)
 else()
-  message(
+  message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
-    WARNING
-      "${MSG_PREFIX} The FSFW_OSAL variable was not set. Assuming host OS..")
-
   # Not set. Assumuing this is a host build, try to determine host OS
   if(WIN32)
     add_subdirectory(host)

src/fsfw/osal/common/TcpIpBase.cpp

@@ -40,8 +40,6 @@ int TcpIpBase::closeSocket(socket_t socket) {
   return closesocket(socket);
 #elif defined(PLATFORM_UNIX)
   return close(socket);
-#else
-  return -1;
 #endif
 }
 
@@ -50,7 +48,5 @@ int TcpIpBase::getLastSocketError() {
   return WSAGetLastError();
 #elif defined(PLATFORM_UNIX)
   return errno;
-#else
-  return 0;
 #endif
 }

src/fsfw/osal/common/TcpTmTcBridge.cpp

@@ -16,9 +16,9 @@
 
 #endif
 
-TcpTmTcBridge::TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
+TcpTmTcBridge::TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination, object_id_t tmStoreId,
-                             uint32_t msgQueueDepth, object_id_t tmStoreId, object_id_t tcStoreId)
+                             object_id_t tcStoreId)
-    : TmTcBridge("TCP TMTC Bridge", objectId, tcDestination, msgQueueDepth, tmStoreId, tcStoreId) {
+    : TmTcBridge("TCP TMTC Bridge", objectId, tcDestination, 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, uint32_t msgQueueDepth,
+  TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
                 object_id_t tmStoreId = objects::TM_STORE,
                 object_id_t tcStoreId = objects::TC_STORE);
   virtual ~TcpTmTcBridge();

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -92,22 +92,12 @@ ReturnValue_t TcpTmTcServer::initialize() {
   }
 
   if (tcpConfig.reuseAddr) {
-#ifdef PLATFORM_WIN
-    DWORD enable = 1;
-    setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&enable),
-               sizeof(enable));
-#elif defined(PLATFORM_UNIX)
     unsigned int enable = 1;
     setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
-#endif
   }
-
   if (tcpConfig.reusePort) {
-// Not supported in windows
-#ifdef PLATFORM_UNIX
     unsigned int enable = 1;
     setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(enable));
-#endif
   }
 
   // Bind to the address found by getaddrinfo

src/fsfw/osal/common/TcpTmTcServer.h

@@ -78,6 +78,7 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
      * https://man7.org/linux/man-pages/man7/socket.7.html for more details.
      */
     bool reusePort = false;
+
   };
   enum class ReceptionModes { SPACE_PACKETS };
 

src/fsfw/osal/common/UdpTmTcBridge.cpp

@@ -21,9 +21,9 @@ typedef SSIZE_T ssize_t;
 const std::string UdpTmTcBridge::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
 
 UdpTmTcBridge::UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
-                             uint32_t msgQueueDepth, const std::string &udpServerPort_,
+                             const std::string &udpServerPort_, object_id_t tmStoreId,
-                             object_id_t tmStoreId, object_id_t tcStoreId)
+                             object_id_t tcStoreId)
-    : TmTcBridge("UDP TMTC Bridge", objectId, tcDestination, msgQueueDepth, tmStoreId, tcStoreId) {
+    : TmTcBridge("UDP TMTC Bridge", objectId, tcDestination, tmStoreId, tcStoreId) {
   if (udpServerPort_.empty()) {
     udpServerPort = DEFAULT_SERVER_PORT;
   } else {
@@ -127,7 +127,10 @@ ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
     tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
   }
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-  sif::debug << "TmTcUdpBridge::sendTm: " << bytesSent << " bytes were sent" << std::endl;
+  sif::debug << "TmTcUdpBridge::sendTm: " << bytesSent
+             << " bytes were"
+                " sent."
+             << std::endl;
 #endif
   return returnvalue::OK;
 }

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, uint32_t msgQueueDepth,
+  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
                 const std::string& udpServerPort = "", object_id_t tmStoreId = objects::TM_STORE,
                 object_id_t tcStoreId = objects::TC_STORE);
   ~UdpTmTcBridge() override;

src/fsfw/osal/linux/Clock.cpp

@@ -33,22 +33,12 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
   return returnvalue::OK;
 }
 
-
-
 timeval Clock::getUptime() {
-  timeval uptime{};
+  timeval uptime{0, 0};
-
   double uptimeSeconds;
-  std::ifstream ifile("/proc/uptime");
+  if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds) {
-  if (ifile.bad()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
-#endif
-    return uptime;
-  }
-  if (ifile >> uptimeSeconds) {
     uptime.tv_sec = uptimeSeconds;
-    uptime.tv_usec = (uptimeSeconds - uptime.tv_sec) * (double)1e6;
+    uptime.tv_usec = uptimeSeconds * (double)1e6 - (uptime.tv_sec * 1e6);
   }
   return uptime;
 }

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::POWER_SWITCH_IF;
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
   //! 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,12 +28,10 @@ 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 ReturnValue_t SWITCH_UNKNOWN = MAKE_RETURN_CODE(5);
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
-
+  static const Event SWITCH_WENT_OFF = MAKE_EVENT(
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::POWER_SWITCH_IF;
+      0, severity::LOW);  //!< Someone detected that a switch went off which shouldn't. Severity:
-  //!< 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);
   /**
    * send a direct command to the Power Unit to enable/disable the specified switch.
    *
@@ -52,7 +50,6 @@ 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/pus/CMakeLists.txt

@@ -9,4 +9,4 @@ target_sources(
           Service17Test.cpp
           Service20ParameterManagement.cpp
           CService200ModeCommanding.cpp
-          CServiceHealthCommanding.cpp)
+          CService201HealthCommanding.cpp)

src/fsfw/pus/CService200ModeCommanding.cpp

@@ -19,8 +19,7 @@ ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
   switch (subservice) {
     case (Subservice::COMMAND_MODE_COMMAND):
     case (Subservice::COMMAND_MODE_READ):
-    case (Subservice::COMMAND_MODE_ANNOUNCE):
+    case (Subservice::COMMAND_MODE_ANNCOUNCE):
-    case (Subservice::COMMAND_MODE_ANNOUNCE_RECURSIVELY):
       return returnvalue::OK;
     default:
       return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
@@ -54,9 +53,6 @@ ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
 ReturnValue_t CService200ModeCommanding::prepareCommand(CommandMessage *message, uint8_t subservice,
                                                         const uint8_t *tcData, size_t tcDataLen,
                                                         uint32_t *state, object_id_t objectId) {
-  bool recursive = false;
-  switch (subservice) {
-    case (Subservice::COMMAND_MODE_COMMAND): {
   ModePacket modeCommandPacket;
   ReturnValue_t result =
       modeCommandPacket.deSerialize(&tcData, &tcDataLen, SerializeIF::Endianness::BIG);
@@ -64,22 +60,9 @@ ReturnValue_t CService200ModeCommanding::prepareCommand(CommandMessage *message,
     return result;
   }
 
-      ModeMessage::setModeMessage(message, ModeMessage::CMD_MODE_COMMAND,
+  ModeMessage::setModeMessage(message, ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
-                                  modeCommandPacket.getMode(), modeCommandPacket.getSubmode());
+                              modeCommandPacket.getSubmode());
-      return returnvalue::OK;
+  return result;
-    }
-    case (Subservice::COMMAND_MODE_ANNOUNCE_RECURSIVELY):
-      recursive = true;
-      [[fallthrough]];
-    case (Subservice::COMMAND_MODE_ANNOUNCE):
-      ModeMessage::setModeAnnounceMessage(*message, recursive);
-      return EXECUTION_COMPLETE;
-    case (Subservice::COMMAND_MODE_READ):
-      ModeMessage::setModeReadMessage(*message);
-      return returnvalue::OK;
-    default:
-      return CommandingServiceBase::INVALID_SUBSERVICE;
-  }
 }
 
 ReturnValue_t CService200ModeCommanding::handleReply(const CommandMessage *reply,
@@ -90,10 +73,8 @@ ReturnValue_t CService200ModeCommanding::handleReply(const CommandMessage *reply
   ReturnValue_t result = returnvalue::FAILED;
   switch (replyId) {
     case (ModeMessage::REPLY_MODE_REPLY): {
-      if (previousCommand != ModeMessage::CMD_MODE_COMMAND) {
+      result = prepareModeReply(reply, objectId);
-        return prepareModeReply(reply, objectId);
+      break;
-      }
-      return returnvalue::OK;
     }
     case (ModeMessage::REPLY_WRONG_MODE_REPLY): {
       result = prepareWrongModeReply(reply, objectId);

src/fsfw/pus/CService200ModeCommanding.h

@@ -52,7 +52,7 @@ class CService200ModeCommanding : public CommandingServiceBase {
     COMMAND_MODE_READ = 3,
     //!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event.
     //! This command does NOT have a reply
-    COMMAND_MODE_ANNOUNCE = 4,
+    COMMAND_MODE_ANNCOUNCE = 4,
     //!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this
     //! command to every child. This command does NOT have a reply.
     COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5,

src/fsfw/pus/CService201HealthCommanding.cpp

@@ -0,0 +1,106 @@
+#include "fsfw/pus/CService201HealthCommanding.h"
+
+#include "fsfw/health/HasHealthIF.h"
+#include "fsfw/health/HealthMessage.h"
+#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/pus/servicepackets/Service201Packets.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId, uint16_t apid,
+                                                         uint8_t serviceId,
+                                                         uint8_t numParallelCommands,
+                                                         uint16_t commandTimeoutSeconds)
+    : CommandingServiceBase(objectId, apid, "PUS 201 Health MGMT", serviceId, numParallelCommands,
+                            commandTimeoutSeconds) {}
+
+ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
+  switch (subservice) {
+    case (Subservice::COMMAND_SET_HEALTH):
+    case (Subservice::COMMAND_ANNOUNCE_HEALTH):
+    case (Subservice::COMMAND_ANNOUNCE_HEALTH_ALL):
+      return returnvalue::OK;
+    default:
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "Invalid Subservice" << std::endl;
+#endif
+      return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+  }
+}
+
+ReturnValue_t CService201HealthCommanding::getMessageQueueAndObject(uint8_t subservice,
+                                                                    const uint8_t *tcData,
+                                                                    size_t tcDataLen,
+                                                                    MessageQueueId_t *id,
+                                                                    object_id_t *objectId) {
+  if (tcDataLen < sizeof(object_id_t)) {
+    return CommandingServiceBase::INVALID_TC;
+  }
+  SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen, SerializeIF::Endianness::BIG);
+
+  return checkInterfaceAndAcquireMessageQueue(id, objectId);
+}
+
+ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
+    MessageQueueId_t *messageQueueToSet, const object_id_t *objectId) {
+  auto *destination = ObjectManager::instance()->get<HasHealthIF>(*objectId);
+  if (destination == nullptr) {
+    return CommandingServiceBase::INVALID_OBJECT;
+  }
+
+  *messageQueueToSet = destination->getCommandQueue();
+  return returnvalue::OK;
+}
+
+ReturnValue_t CService201HealthCommanding::prepareCommand(CommandMessage *message,
+                                                          uint8_t subservice, const uint8_t *tcData,
+                                                          size_t tcDataLen, uint32_t *state,
+                                                          object_id_t objectId) {
+  ReturnValue_t result = returnvalue::OK;
+  switch (subservice) {
+    case (Subservice::COMMAND_SET_HEALTH): {
+      HealthSetCommand healthCommand;
+      result = healthCommand.deSerialize(&tcData, &tcDataLen, SerializeIF::Endianness::BIG);
+      if (result != returnvalue::OK) {
+        break;
+      }
+      HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_SET,
+                                      healthCommand.getHealth());
+      break;
+    }
+    case (Subservice::COMMAND_ANNOUNCE_HEALTH): {
+      HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_ANNOUNCE);
+      break;
+    }
+    case (Subservice::COMMAND_ANNOUNCE_HEALTH_ALL): {
+      HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_ANNOUNCE_ALL);
+      break;
+    }
+    default: {
+      // Should never happen, subservice was already checked
+      result = returnvalue::FAILED;
+    }
+  }
+  return result;
+}
+
+ReturnValue_t CService201HealthCommanding::handleReply(const CommandMessage *reply,
+                                                       Command_t previousCommand, uint32_t *state,
+                                                       CommandMessage *optionalNextCommand,
+                                                       object_id_t objectId, bool *isStep) {
+  Command_t replyId = reply->getCommand();
+  if (replyId == HealthMessage::REPLY_HEALTH_SET) {
+    return EXECUTION_COMPLETE;
+  } else if (replyId == CommandMessageIF::REPLY_REJECTED) {
+    return reply->getReplyRejectedReason();
+  }
+  return CommandingServiceBase::INVALID_REPLY;
+}
+
+// Not used for now, health state already reported by event
+[[maybe_unused]] ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(
+    const CommandMessage *reply) {
+  auto health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
+  auto oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
+  HealthSetReply healthSetReply(health, oldHealth);
+  return sendTmPacket(Subservice::REPLY_HEALTH_SET, healthSetReply);
+}

src/fsfw/pus/CService201HealthCommanding.h

@@ -1,26 +1,8 @@
 #ifndef FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
 #define FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
 
-#include <fsfw/health/HealthTable.h>
-
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
 
-struct HealthServiceCfg {
-  HealthServiceCfg(object_id_t objectId, uint16_t apid, object_id_t healthTable,
-                   uint16_t maxNumHealthInfoPerCycle)
-      : objectId(objectId),
-        apid(apid),
-        table(healthTable),
-        maxNumHealthInfoPerCycle(maxNumHealthInfoPerCycle) {}
-  object_id_t objectId;
-  uint16_t apid;
-  object_id_t table;
-  uint16_t maxNumHealthInfoPerCycle;
-  uint8_t service = 201;
-  uint8_t numParallelCommands = 4;
-  uint16_t commandTimeoutSeconds = 60;
-};
-
 /**
  * @brief   Custom PUS service to set health of all objects
  *          implementing hasHealthIF.
@@ -35,12 +17,11 @@ struct HealthServiceCfg {
  * child class like this service
  *
  */
-class CServiceHealthCommanding : public CommandingServiceBase {
+class CService201HealthCommanding : public CommandingServiceBase {
  public:
-  CServiceHealthCommanding(HealthServiceCfg args);
+  CService201HealthCommanding(object_id_t objectId, uint16_t apid, uint8_t serviceId,
-  ~CServiceHealthCommanding() override = default;
+                              uint8_t numParallelCommands = 4, uint16_t commandTimeoutSeconds = 60);
-
+  ~CService201HealthCommanding() override = default;
-  ReturnValue_t initialize() override;
 
  protected:
   /* CSB abstract function implementations */
@@ -56,14 +37,7 @@ class CServiceHealthCommanding : public CommandingServiceBase {
                             CommandMessage *optionalNextCommand, object_id_t objectId,
                             bool *isStep) override;
 
-  void doPeriodicOperation() override;
-
  private:
-  const object_id_t healthTableId;
-  HealthTable *healthTable;
-  uint16_t maxNumHealthInfoPerCycle = 0;
-  bool reportAllHealth = false;
-  ReturnValue_t iterateHealthTable(bool reset);
   static ReturnValue_t checkInterfaceAndAcquireMessageQueue(MessageQueueId_t *MessageQueueToSet,
                                                             const object_id_t *objectId);
 

src/fsfw/pus/CServiceHealthCommanding.cpp

@@ -1,161 +0,0 @@
-#include <fsfw/events/EventManagerIF.h>
-#include <fsfw/pus/CServiceHealthCommanding.h>
-
-#include "fsfw/health/HasHealthIF.h"
-#include "fsfw/health/HealthMessage.h"
-#include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/pus/servicepackets/Service201Packets.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
-
-CServiceHealthCommanding::CServiceHealthCommanding(HealthServiceCfg args)
-    : CommandingServiceBase(args.objectId, args.apid, "PUS 201 Health MGMT", args.service,
-                            args.numParallelCommands, args.commandTimeoutSeconds),
-      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):
-    case (Subservice::COMMAND_ANNOUNCE_HEALTH):
-    case (Subservice::COMMAND_ANNOUNCE_HEALTH_ALL):
-      return returnvalue::OK;
-    default:
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "Invalid Subservice" << std::endl;
-#endif
-      return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-  }
-}
-
-ReturnValue_t CServiceHealthCommanding::getMessageQueueAndObject(uint8_t subservice,
-                                                                 const uint8_t *tcData,
-                                                                 size_t tcDataLen,
-                                                                 MessageQueueId_t *id,
-                                                                 object_id_t *objectId) {
-  switch (subservice) {
-    case (Subservice::COMMAND_SET_HEALTH):
-    case (Subservice::COMMAND_ANNOUNCE_HEALTH): {
-      if (tcDataLen < sizeof(object_id_t)) {
-        return CommandingServiceBase::INVALID_TC;
-      }
-      SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen, SerializeIF::Endianness::BIG);
-
-      return checkInterfaceAndAcquireMessageQueue(id, objectId);
-    }
-    case (Subservice::COMMAND_ANNOUNCE_HEALTH_ALL): {
-      return returnvalue::OK;
-    }
-    default: {
-      return returnvalue::FAILED;
-    }
-  }
-}
-
-ReturnValue_t CServiceHealthCommanding::checkInterfaceAndAcquireMessageQueue(
-    MessageQueueId_t *messageQueueToSet, const object_id_t *objectId) {
-  auto *destination = ObjectManager::instance()->get<HasHealthIF>(*objectId);
-  if (destination == nullptr) {
-    return CommandingServiceBase::INVALID_OBJECT;
-  }
-
-  *messageQueueToSet = destination->getCommandQueue();
-  return returnvalue::OK;
-}
-
-ReturnValue_t CServiceHealthCommanding::prepareCommand(CommandMessage *message, uint8_t subservice,
-                                                       const uint8_t *tcData, size_t tcDataLen,
-                                                       uint32_t *state, object_id_t objectId) {
-  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) {
-        break;
-      }
-      HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_SET,
-                                      healthCommand.getHealth());
-      break;
-    }
-    case (Subservice::COMMAND_ANNOUNCE_HEALTH): {
-      HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_ANNOUNCE);
-      return CommandingServiceBase::EXECUTION_COMPLETE;
-    }
-    case (Subservice::COMMAND_ANNOUNCE_HEALTH_ALL): {
-      ReturnValue_t result = iterateHealthTable(true);
-      if (result == returnvalue::OK) {
-        reportAllHealth = true;
-        return EXECUTION_COMPLETE;
-      }
-      return result;
-    }
-    default: {
-      // Should never happen, subservice was already checked
-      result = returnvalue::FAILED;
-    }
-  }
-  return result;
-}
-
-ReturnValue_t CServiceHealthCommanding::handleReply(const CommandMessage *reply,
-                                                    Command_t previousCommand, uint32_t *state,
-                                                    CommandMessage *optionalNextCommand,
-                                                    object_id_t objectId, bool *isStep) {
-  Command_t replyId = reply->getCommand();
-  if (replyId == HealthMessage::REPLY_HEALTH_SET) {
-    return EXECUTION_COMPLETE;
-  } else if (replyId == CommandMessageIF::REPLY_REJECTED) {
-    return reply->getReplyRejectedReason();
-  }
-  return CommandingServiceBase::INVALID_REPLY;
-}
-
-void CServiceHealthCommanding::doPeriodicOperation() {
-  if (reportAllHealth) {
-    for (uint8_t i = 0; i < maxNumHealthInfoPerCycle; i++) {
-      ReturnValue_t result = iterateHealthTable(false);
-      if (result != returnvalue::OK) {
-        reportAllHealth = false;
-        break;
-      }
-    }
-  }
-}
-
-// Not used for now, health state already reported by event
-[[maybe_unused]] ReturnValue_t CServiceHealthCommanding::prepareHealthSetReply(
-    const CommandMessage *reply) {
-  auto health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
-  auto oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
-  HealthSetReply healthSetReply(health, oldHealth);
-  return sendTmPacket(Subservice::REPLY_HEALTH_SET, healthSetReply);
-}
-
-ReturnValue_t CServiceHealthCommanding::iterateHealthTable(bool reset) {
-  std::pair<object_id_t, HasHealthIF::HealthState> pair;
-
-  ReturnValue_t result = healthTable->iterate(&pair, reset);
-  if (result != returnvalue::OK) {
-    return result;
-  } else {
-    EventManagerIF::triggerEvent(pair.first, HasHealthIF::HEALTH_INFO, pair.second, pair.second);
-    return returnvalue::OK;
-  }
-}

src/fsfw/serialize/SerialBufferAdapter.cpp

@@ -20,9 +20,6 @@ SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer, count_t buffe
       buffer(buffer),
       bufferLength(bufferLength) {}
 
-template <typename count_t>
-SerialBufferAdapter<count_t>::~SerialBufferAdapter() = default;
-
 template <typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer_, size_t* size,
                                                       size_t maxSize,

src/fsfw/serialize/SerialBufferAdapter.h

@@ -41,7 +41,7 @@ class SerialBufferAdapter : public SerializeIF {
    */
   SerialBufferAdapter(uint8_t* buffer, count_t bufferLength, bool serializeLength = false);
 
-  ~SerialBufferAdapter() override;
+  ~SerialBufferAdapter() override = default;
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           Endianness streamEndianness) const override;
@@ -74,4 +74,10 @@ class SerialBufferAdapter : public SerializeIF {
   count_t bufferLength = 0;
 };
 
+// declaration of explicit instantiations (which are in the cpp)
+extern template class SerialBufferAdapter<uint8_t>;
+extern template class SerialBufferAdapter<uint16_t>;
+extern template class SerialBufferAdapter<uint32_t>;
+extern template class SerialBufferAdapter<uint64_t>;
+
 #endif /* SERIALBUFFERADAPTER_H_ */

src/fsfw/serialize/SerializeIF.h

@@ -35,6 +35,12 @@ class SerializeIF {
       MAKE_RETURN_CODE(3);  // !< There are too many elements to be deserialized
 
   virtual ~SerializeIF() = default;
+  // C++11 deprecates automatic generation of copy ctor and assignment operator when
+  // a destructor is defined, so we need to explicitely set them to default
+  SerializeIF(const SerializeIF&) = default;
+  SerializeIF() = default;
+  SerializeIF& operator= ( const SerializeIF & ) = default;
+
   /**
    * @brief
    * Function to serialize the object into a buffer with maxSize. Size represents the written

src/fsfw/storagemanager/storeAddress.h

@@ -22,7 +22,7 @@ union store_address_t {
    */
   explicit store_address_t(uint32_t rawAddress) : raw(rawAddress) {}
 
-  static store_address_t invalid() { return {}; };
+  static store_address_t invalid() { return {}; }
 
   /**
    * Constructor to create an address object using pool

src/fsfw/tasks/ExecutableObjectIF.h

@@ -34,7 +34,7 @@ class ExecutableObjectIF {
    * a reference to the executing task
    * @param task_ Pointer to the taskIF of this task
    */
-  virtual void setTaskIF(PeriodicTaskIF* task_){};
+  virtual void setTaskIF(PeriodicTaskIF* task_){}
 
   /**
    * This function should be called after the object was assigned to a

src/fsfw/timemanager/CdsShortTimeStamper.cpp

@@ -4,8 +4,6 @@
 
 #include "fsfw/timemanager/Clock.h"
 
-CdsShortTimeStamper::CdsShortTimeStamper() : SystemObject(0, false) {}
-
 CdsShortTimeStamper::CdsShortTimeStamper(object_id_t objectId) : SystemObject(objectId) {}
 
 ReturnValue_t CdsShortTimeStamper::serialize(uint8_t **buffer, size_t *size, size_t maxSize,

src/fsfw/timemanager/CdsShortTimeStamper.h

@@ -18,7 +18,6 @@
 class CdsShortTimeStamper : public TimeWriterIF, public TimeReaderIF, public SystemObject {
  public:
   static constexpr size_t TIMESTAMP_LEN = 7;
-  CdsShortTimeStamper();
   /**
    * @brief   Default constructor which also registers the time stamper as a
    *          system object so it can be found with the #objectManager.

src/fsfw/tmtcpacket/pus/RawUserDataReaderIF.h

@@ -6,7 +6,7 @@
 
 class RawUserDataReaderIF {
  public:
-  ~RawUserDataReaderIF() = default;
+  virtual ~RawUserDataReaderIF() = default;
   [[nodiscard]] virtual const uint8_t* getUserData() const = 0;
   [[nodiscard]] virtual size_t getUserDataLen() const = 0;
 };

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,
-                       uint32_t msgQueueDepth, object_id_t tmStoreId, object_id_t tcStoreId)
+                       object_id_t tmStoreId, object_id_t tcStoreId)
     : SystemObject(objectId),
       name(name),
       tmStoreId(tmStoreId),
@@ -16,9 +16,7 @@ TmTcBridge::TmTcBridge(const char* name, object_id_t objectId, object_id_t tcDes
       tcDestination(tcDestination)
 
 {
-  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
+  tmTcReceptionQueue = QueueFactory::instance()->createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
-  tmTcReceptionQueue = QueueFactory::instance()->createMessageQueue(
-      msgQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 TmTcBridge::~TmTcBridge() { QueueFactory::instance()->deleteMessageQueue(tmTcReceptionQueue); }
@@ -37,7 +35,7 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(uint8_t sentPacketsPerC
   }
 }
 
-ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(unsigned int maxNumberOfPacketsStored) {
+ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored) {
   if (maxNumberOfPacketsStored <= LIMIT_DOWNLINK_PACKETS_STORED) {
     this->maxNumberOfPacketsStored = maxNumberOfPacketsStored;
     return returnvalue::OK;
@@ -145,17 +143,13 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 #endif /* FSFW_VERBOSE_LEVEL >= 3 */
 
     if (communicationLinkUp == false or packetSentCounter >= sentPacketsPerCycle) {
-      ReturnValue_t result = storeDownlinkData(&message);
+      storeDownlinkData(&message);
-      if (result != returnvalue::OK) {
-        tmStore->deleteData(message.getStorageId());
-      }
       continue;
     }
 
     result = tmStore->getData(message.getStorageId(), &data, &size);
     if (result != returnvalue::OK) {
       status = result;
-      tmStore->deleteData(message.getStorageId());
       continue;
     }
 
@@ -163,9 +157,9 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
     if (result != returnvalue::OK) {
       status = result;
     } else {
+      tmStore->deleteData(message.getStorageId());
       packetSentCounter++;
     }
-    tmStore->deleteData(message.getStorageId());
   }
   return status;
 }
@@ -177,7 +171,6 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage* message) {
   }
 
   if (tmFifo->full()) {
-    if (warningSwitch) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "TmTcBridge::storeDownlinkData: TM downlink max. number "
                     "of stored packet IDs reached!"
@@ -187,8 +180,6 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage* message) {
         "TmTcBridge::storeDownlinkData: TM downlink max. number "
         "of stored packet IDs reached!\n");
 #endif
-      warningSwitch = false;
-    }
     if (overwriteOld) {
       tmFifo->retrieve(&storeId);
       tmStore->deleteData(storeId);
@@ -230,7 +221,6 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
     packetSentCounter++;
 
     if (tmFifo->empty()) {
-      warningSwitch = true;
       tmStored = false;
     }
     tmStore->deleteData(storeId);

src/fsfw/tmtcservices/TmTcBridge.h

@@ -15,14 +15,15 @@ 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;
+  static constexpr uint8_t LIMIT_DOWNLINK_PACKETS_STORED = 200;
 
   static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
   static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
 
   TmTcBridge(const char* name, object_id_t objectId, object_id_t tcDestination,
-             uint32_t msgQueueDepth, object_id_t tmStoreId, object_id_t tcStoreId);
+             object_id_t tmStoreId, object_id_t tcStoreId);
   ~TmTcBridge() override;
 
   /**
@@ -41,7 +42,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
    * @return -@c returnvalue::OK if value was set successfully
    *         -@c returnvalue::FAILED otherwise, stored value stays the same
    */
-  ReturnValue_t setMaxNumberOfPacketsStored(unsigned int maxNumberOfPacketsStored);
+  ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
 
   /**
    * This will set up the bridge to overwrite old data in the FIFO.
@@ -90,7 +91,6 @@ class TmTcBridge : public AcceptsTelemetryIF,
   //! by default, so telemetry will be handled immediately.
   bool communicationLinkUp = true;
   bool tmStored = false;
-  bool warningSwitch = true;
   bool overwriteOld = true;
   uint8_t packetSentCounter = 0;
 
@@ -152,7 +152,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
    */
   DynamicFIFO<store_address_t>* tmFifo = nullptr;
   uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
-  unsigned int maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
+  uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };
 
 #endif /* FSFW_TMTCSERVICES_TMTCBRIDGE_H_ */

src/fsfw/version.cpp

@@ -1,7 +1,6 @@
 #include "version.h"
 
 #include <cstdio>
-#include <cstring>
 
 #include "fsfw/FSFWVersion.h"
 
@@ -21,7 +20,7 @@ fsfw::Version::Version(int major, int minor, int revision, const char* addInfo)
 
 void fsfw::Version::getVersion(char* str, size_t maxLen) const {
   size_t len = snprintf(str, maxLen, "%d.%d.%d", major, minor, revision);
-  if (addInfo != nullptr and std::strcmp(addInfo, "") != 0) {
+  if (addInfo != nullptr) {
     snprintf(str + len, maxLen - len, "-%s", addInfo);
   }
 }
@@ -31,7 +30,7 @@ namespace fsfw {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 std::ostream& operator<<(std::ostream& os, const Version& v) {
   os << v.major << "." << v.minor << "." << v.revision;
-  if (v.addInfo != nullptr and std::strcmp(v.addInfo, "") != 0) {
+  if (v.addInfo != nullptr) {
     os << "-" << v.addInfo;
   }
   return os;

src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -325,7 +325,7 @@ ReturnValue_t MgmRM3100Handler::handleDataReadout(const uint8_t *packet) {
   // trickery here to calculate the raw values first
   int32_t fieldStrengthRawX = ((packet[1] << 24) | (packet[2] << 16) | (packet[3] << 8)) >> 8;
   int32_t fieldStrengthRawY = ((packet[4] << 24) | (packet[5] << 16) | (packet[6] << 8)) >> 8;
-  int32_t fieldStrengthRawZ = ((packet[7] << 24) | (packet[8] << 16) | (packet[9] << 8)) >> 8;
+  int32_t fieldStrengthRawZ = ((packet[7] << 24) | (packet[8] << 16) | (packet[3] << 8)) >> 8;
 
   // Now scale to physical value in microtesla
   float fieldStrengthX = fieldStrengthRawX * scaleFactorX;

unittests/CatchFactory.cpp

@@ -30,7 +30,7 @@
  */
 void Factory::produceFrameworkObjects(void* args) {
   setStaticFrameworkObjectIds();
-  new EventManager(objects::EVENT_MANAGER, 80);
+  new EventManager(objects::EVENT_MANAGER);
   new HealthTable(objects::HEALTH_TABLE);
   new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
 

unittests/testcfg/rtems/cmake/aarch64-rtems6-toolchain.cmake

@@ -31,3 +31,6 @@ add_compile_definitions("__STDC_VERSION__")
 # make newlib behave like glib with an intercepted cmath
 add_compile_options("-I${CMAKE_SOURCE_DIR}/unittests/testcfg/rtems/include")
 
+# we supply an a72_lp64_qemu.cmake there
+list(APPEND CMAKE_MODULE_PATH
+     "${CMAKE_CURRENT_SOURCE_DIR}/unittests/testcfg/rtems/cmake")