1
0
forked from fsfw/fsfw

Merge remote-tracking branch 'origin/development' into mueller/refactor-tmtc-stack-with-retval-refactoring

This commit is contained in:
2022-08-22 15:57:22 +02:00
163 changed files with 397 additions and 569 deletions
CHANGELOG.md
docs
misc/defaultcfg/fsfwconfig/pollingsequence
src
fsfw
action
cfdp
container
coordinates
datalinklayer
datapool
datapoollocal
devicehandlers
events
eventmatching
fdir
globalfunctions
health
ipc
memory
modes
monitoring
objectmanager
osal
parameters
power
pus
returnvalues
retval.h
rmap
serialize
serviceinterface
storagemanager
subsystem
tasks
tcdistribution
thermal
timemanager
tmstorage
tmtcpacket
tmtcservices
fsfw_hal
fsfw_tests
unittests

@ -10,6 +10,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
# [v6.0.0] # [v6.0.0]
## Changes
## Added ## Added
- Add new `UnsignedByteField` class - Add new `UnsignedByteField` class
@ -41,7 +43,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
- HAL Devicehandlers: Periodic printout is run-time configurable now - HAL Devicehandlers: Periodic printout is run-time configurable now
- `oneShotAction` flag in the `TestTask` class is not static anymore - `oneShotAction` flag in the `TestTask` class is not static anymore
- `SimpleRingBuffer::writeData` now checks if the amount is larger than the total size of the - `SimpleRingBuffer::writeData` now checks if the amount is larger than the total size of the
Buffer and rejects such writeData calls with `HasReturnvaluesIF::RETURN_FAILED` Buffer and rejects such writeData calls with `returnvalue::FAILED`
PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/586 PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/586
- Major update for version handling, using `git describe` to fetch version information with git. - Major update for version handling, using `git describe` to fetch version information with git.
PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/601 PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/601

@ -14,7 +14,7 @@ FSFW to achieve that. The fsfw uses run-time type information but exceptions are
# Failure Handling # Failure Handling
Functions should return a defined `ReturnValue_t` to signal to the caller that something has Functions should return a defined `ReturnValue_t` to signal to the caller that something has
gone wrong. Returnvalues must be unique. For this the function `HasReturnvaluesIF::makeReturnCode` gone wrong. Returnvalues must be unique. For this the function `returnvalue::makeCode`
or the macro `MAKE_RETURN` can be used. The `CLASS_ID` is a unique id for that type of object. or the macro `MAKE_RETURN` can be used. The `CLASS_ID` is a unique id for that type of object.
See `returnvalues/FwClassIds` folder. The user can add custom `CLASS_ID`s via the See `returnvalues/FwClassIds` folder. The user can add custom `CLASS_ID`s via the
`fsfwconfig` folder. `fsfwconfig` folder.

@ -144,7 +144,7 @@ ReturnValue_t GyroHandler::initializeLocalDataPool(localpool::DataPool &localDat
new PoolEntry<uint8_t>({0})); new PoolEntry<uint8_t>({0}));
poolManager.subscribeForPeriodicPacket(gyroData.getSid(), false, 4.0, false); poolManager.subscribeForPeriodicPacket(gyroData.getSid(), false, 4.0, false);
return HasReturnvaluesIF::RETURN_OK; return returnvalue::OK;
} }
``` ```
@ -154,7 +154,7 @@ in any case:
```cpp ```cpp
PoolReadGuard readHelper(&gyroData); PoolReadGuard readHelper(&gyroData);
if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) { if(readHelper.getReadResult() == returnvalue::OK) {
if(not gyroData.isValid()) { if(not gyroData.isValid()) {
gyroData.setValidity(true, true); gyroData.setValidity(true, true);
} }

@ -3,7 +3,7 @@
Returnvalue API Returnvalue API
================== ==================
.. doxygenfile:: HasReturnvaluesIF.h .. doxygenfile:: returnvalue.h
.. _fwclassids: .. _fwclassids:

@ -75,11 +75,11 @@ and the respective source file with sensible default return values:
void TestDeviceHandler::doShutDown() {} void TestDeviceHandler::doShutDown() {}
ReturnValue_t TestDeviceHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) { ReturnValue_t TestDeviceHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
return HasReturnvaluesIF::RETURN_OK; return returnvalue::OK;
} }
ReturnValue_t TestDeviceHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) { ReturnValue_t TestDeviceHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
return HasReturnvaluesIF::RETURN_OK; return returnvalue::OK;
} }
void TestDeviceHandler::fillCommandAndReplyMap() {} void TestDeviceHandler::fillCommandAndReplyMap() {}
@ -87,17 +87,17 @@ and the respective source file with sensible default return values:
ReturnValue_t TestDeviceHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand, ReturnValue_t TestDeviceHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
const uint8_t* commandData, const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
return HasReturnvaluesIF::RETURN_OK; return returnvalue::OK;
} }
ReturnValue_t TestDeviceHandler::scanForReply(const uint8_t* start, size_t remainingSize, ReturnValue_t TestDeviceHandler::scanForReply(const uint8_t* start, size_t remainingSize,
DeviceCommandId_t* foundId, size_t* foundLen) { DeviceCommandId_t* foundId, size_t* foundLen) {
return HasReturnvaluesIF::RETURN_OK; return returnvalue::OK;
} }
ReturnValue_t TestDeviceHandler::interpretDeviceReply(DeviceCommandId_t id, ReturnValue_t TestDeviceHandler::interpretDeviceReply(DeviceCommandId_t id,
const uint8_t* packet) { const uint8_t* packet) {
return HasReturnvaluesIF::RETURN_OK; return returnvalue::OK;
} }
uint32_t TestDeviceHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { uint32_t TestDeviceHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
@ -106,5 +106,5 @@ and the respective source file with sensible default return values:
ReturnValue_t TestDeviceHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap, ReturnValue_t TestDeviceHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
LocalDataPoolManager& poolManager) { LocalDataPoolManager& poolManager) {
return HasReturnvaluesIF::RETURN_OK; return returnvalue::OK;
} }

@ -18,7 +18,7 @@ Failure Handling
----------------- -----------------
Functions should return a defined :cpp:type:`ReturnValue_t` to signal to the caller that something has Functions should return a defined :cpp:type:`ReturnValue_t` to signal to the caller that something has
gone wrong. Returnvalues must be unique. For this the function :cpp:func:`HasReturnvaluesIF::makeReturnCode` gone wrong. Returnvalues must be unique. For this the function :cpp:func:`returnvalue::makeCode`
or the :ref:`macro MAKE_RETURN_CODE <retvalapi>` can be used. The ``CLASS_ID`` is a unique ID for that type of object. or the :ref:`macro MAKE_RETURN_CODE <retvalapi>` can be used. The ``CLASS_ID`` is a unique ID for that type of object.
See the :ref:`FSFW Class IDs file <fwclassids>`. The user can add custom ``CLASS_ID``\s via the See the :ref:`FSFW Class IDs file <fwclassids>`. The user can add custom ``CLASS_ID``\s via the
``fsfwconfig`` folder. ``fsfwconfig`` folder.

@ -150,7 +150,7 @@ with a housekeeping service command.
new PoolEntry<uint8_t>({0})); new PoolEntry<uint8_t>({0}));
poolManager.subscribeForPeriodicPacket(gyroData.getSid(), false, 4.0, false); poolManager.subscribeForPeriodicPacket(gyroData.getSid(), false, 4.0, false);
return HasReturnvaluesIF::RETURN_OK; return returnvalue::OK;
} }
Now, if we receive some sensor data and converted them into the right format, Now, if we receive some sensor data and converted them into the right format,
@ -160,7 +160,7 @@ in any case:
.. code-block:: cpp .. code-block:: cpp
PoolReadGuard readHelper(&gyroData); PoolReadGuard readHelper(&gyroData);
if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) { if(readHelper.getReadResult() == returnvalue::OK) {
if(not gyroData.isValid()) { if(not gyroData.isValid()) {
gyroData.setValidity(true, true); gyroData.setValidity(true, true);
} }

@ -1,7 +1,7 @@
#ifndef POLLINGSEQUENCEFACTORY_H_ #ifndef POLLINGSEQUENCEFACTORY_H_
#define POLLINGSEQUENCEFACTORY_H_ #define POLLINGSEQUENCEFACTORY_H_
#include <fsfw/returnvalues/HasReturnvaluesIF.h> #include <fsfw/returnvalues/returnvalue.h>
class FixedTimeslotTaskIF; class FixedTimeslotTaskIF;

@ -45,7 +45,7 @@ class ActionHelper {
* helper function * helper function
* @param queueToUse_ Pointer to the messageQueue to be used, optional * @param queueToUse_ Pointer to the messageQueue to be used, optional
* if queue was set in constructor * if queue was set in constructor
* @return Returns RETURN_OK if successful * @return Returns returnvalue::OK if successful
*/ */
ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr); ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
/** /**
@ -75,7 +75,7 @@ class ActionHelper {
* message to * message to
* @param replyId ID of the executed command * @param replyId ID of the executed command
* @param data Pointer to the data * @param data Pointer to the data
* @return Returns RETURN_OK if successful, otherwise failure code * @return Returns returnvalue::OK if successful, otherwise failure code
*/ */
ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data, ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data,
bool hideSender = false); bool hideSender = false);
@ -86,7 +86,7 @@ class ActionHelper {
* message to * message to
* @param replyId ID of the executed command * @param replyId ID of the executed command
* @param data Pointer to the data * @param data Pointer to the data
* @return Returns RETURN_OK if successful, otherwise failure code * @return Returns returnvalue::OK if successful, otherwise failure code
*/ */
ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, const uint8_t* data, ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, const uint8_t* data,
size_t dataSize, bool hideSender = false); size_t dataSize, bool hideSender = false);

@ -4,7 +4,7 @@
#include "ActionMessage.h" #include "ActionMessage.h"
#include "fsfw/ipc/MessageQueueIF.h" #include "fsfw/ipc/MessageQueueIF.h"
#include "fsfw/objectmanager/ObjectManagerIF.h" #include "fsfw/objectmanager/ObjectManagerIF.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/serialize/SerializeIF.h" #include "fsfw/serialize/SerializeIF.h"
#include "fsfw/storagemanager/StorageManagerIF.h" #include "fsfw/storagemanager/StorageManagerIF.h"

@ -3,7 +3,7 @@
#include "CommandActionHelper.h" #include "CommandActionHelper.h"
#include "fsfw/ipc/MessageQueueIF.h" #include "fsfw/ipc/MessageQueueIF.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
/** /**
* Interface to separate commanding actions of other objects. * Interface to separate commanding actions of other objects.

@ -5,7 +5,7 @@
#include "ActionMessage.h" #include "ActionMessage.h"
#include "SimpleActionHelper.h" #include "SimpleActionHelper.h"
#include "fsfw/ipc/MessageQueueIF.h" #include "fsfw/ipc/MessageQueueIF.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
/** /**
* @brief * @brief
@ -53,7 +53,7 @@ class HasActionsIF {
* *
* @return * @return
* -@c EXECUTION_FINISHED Finish reply will be generated * -@c EXECUTION_FINISHED Finish reply will be generated
* -@c Not RETURN_OK Step failure reply will be generated * -@c Not returnvalue::OK Step failure reply will be generated
*/ */
virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
const uint8_t* data, size_t size) = 0; const uint8_t* data, size_t size) = 0;

@ -3,7 +3,7 @@
#include "fsfw/ipc/MessageQueueIF.h" #include "fsfw/ipc/MessageQueueIF.h"
#include "fsfw/objectmanager/SystemObject.h" #include "fsfw/objectmanager/SystemObject.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/tasks/ExecutableObjectIF.h" #include "fsfw/tasks/ExecutableObjectIF.h"
#include "fsfw/tcdistribution/CFDPDistributor.h" #include "fsfw/tcdistribution/CFDPDistributor.h"
#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h" #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"

@ -7,7 +7,7 @@
#include <cstdint> #include <cstdint>
#include "fsfw/returnvalues/FwClassIds.h" #include "fsfw/returnvalues/FwClassIds.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
namespace cfdp { namespace cfdp {

@ -36,7 +36,7 @@ class HeaderDeserializer : public RedirectableDataPointerIF, public PduHeaderIF
/** /**
* This needs to be called before accessing the PDU fields to avoid segmentation faults. * This needs to be called before accessing the PDU fields to avoid segmentation faults.
* @return * @return
* - RETURN_OK on parse success * - returnvalue::OK on parse success
* - returnvalue::FAILED Invalid raw data * - returnvalue::FAILED Invalid raw data
* - SerializeIF::BUFFER_TOO_SHORT if buffer is shorter than expected * - SerializeIF::BUFFER_TOO_SHORT if buffer is shorter than expected
*/ */

@ -23,7 +23,7 @@ class Tlv : public TlvIF {
* @param maxSize * @param maxSize
* @param streamEndianness * @param streamEndianness
* @return * @return
* - RETURN_OK on success * - returnvalue::OK on success
* - INVALID_TLV_TYPE * - INVALID_TLV_TYPE
* - SerializeIF returncode on wrong serialization parameters * - SerializeIF returncode on wrong serialization parameters
*/ */
@ -37,7 +37,7 @@ class Tlv : public TlvIF {
* @param buffer Raw buffer including the size field * @param buffer Raw buffer including the size field
* @param size * @param size
* @param streamEndianness * @param streamEndianness
* - RETURN_OK on success * - returnvalue::OK on success
* - INVALID_TLV_TYPE * - INVALID_TLV_TYPE
* - SerializeIF returncode on wrong deserialization parameters * - SerializeIF returncode on wrong deserialization parameters
*/ */

@ -1,7 +1,7 @@
#ifndef FSFW_CONTAINER_ARRAYLIST_H_ #ifndef FSFW_CONTAINER_ARRAYLIST_H_
#define FSFW_CONTAINER_ARRAYLIST_H_ #define FSFW_CONTAINER_ARRAYLIST_H_
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "../serialize/SerializeAdapter.h" #include "../serialize/SerializeAdapter.h"
#include "../serialize/SerializeIF.h" #include "../serialize/SerializeIF.h"
@ -183,7 +183,7 @@ class ArrayList {
* @param entry * @param entry
* @return * @return
* -@c FULL if the List is full * -@c FULL if the List is full
* -@c RETURN_OK else * -@c returnvalue::OK else
*/ */
ReturnValue_t insert(T entry) { ReturnValue_t insert(T entry) {
if (size >= maxSize_) { if (size >= maxSize_) {

@ -4,7 +4,7 @@
#include <cstddef> #include <cstddef>
#include <cstring> #include <cstring>
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
template <typename T> template <typename T>
class FIFOBase { class FIFOBase {
@ -20,24 +20,24 @@ class FIFOBase {
/** /**
* Insert value into FIFO * Insert value into FIFO
* @param value * @param value
* @return RETURN_OK on success, FULL if full * @return returnvalue::OK on success, FULL if full
*/ */
ReturnValue_t insert(T value); ReturnValue_t insert(T value);
/** /**
* Retrieve item from FIFO. This removes the item from the FIFO. * Retrieve item from FIFO. This removes the item from the FIFO.
* @param value Must point to a valid T * @param value Must point to a valid T
* @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed * @return returnvalue::OK on success, EMPTY if empty and FAILED if nullptr check failed
*/ */
ReturnValue_t retrieve(T* value); ReturnValue_t retrieve(T* value);
/** /**
* Retrieve item from FIFO without removing it from FIFO. * Retrieve item from FIFO without removing it from FIFO.
* @param value Must point to a valid T * @param value Must point to a valid T
* @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed * @return returnvalue::OK on success, EMPTY if empty and FAILED if nullptr check failed
*/ */
ReturnValue_t peek(T* value); ReturnValue_t peek(T* value);
/** /**
* Remove item from FIFO. * Remove item from FIFO.
* @return RETURN_OK on success, EMPTY if empty * @return returnvalue::OK on success, EMPTY if empty
*/ */
ReturnValue_t pop(); ReturnValue_t pop();

@ -4,7 +4,7 @@
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "ArrayList.h" #include "ArrayList.h"
/** /**

@ -100,7 +100,7 @@ class FixedOrderedMultimap {
* @param[in] value Value of the new element * @param[in] value Value of the new element
* @param[in/out] (optional) storedValue On success this points to the new value, otherwise a * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a
* nullptr * nullptr
* @return RETURN_OK if insert was successful, MAP_FULL if no space is available * @return returnvalue::OK if insert was successful, MAP_FULL if no space is available
*/ */
ReturnValue_t insert(key_t key, T value, Iterator* storedValue = nullptr); ReturnValue_t insert(key_t key, T value, Iterator* storedValue = nullptr);
@ -108,14 +108,14 @@ class FixedOrderedMultimap {
* Used to insert new pair instead of single values * Used to insert new pair instead of single values
* *
* @param pair Pair to be inserted * @param pair Pair to be inserted
* @return RETURN_OK if insert was successful, MAP_FULL if no space is available * @return returnvalue::OK if insert was successful, MAP_FULL if no space is available
*/ */
ReturnValue_t insert(std::pair<key_t, T> pair); ReturnValue_t insert(std::pair<key_t, T> pair);
/*** /***
* Can be used to check if a certain key is in the map * Can be used to check if a certain key is in the map
* @param key Key to be checked * @param key Key to be checked
* @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise * @return returnvalue::OK if the key exists KEY_DOES_NOT_EXIST otherwise
*/ */
ReturnValue_t exists(key_t key) const; ReturnValue_t exists(key_t key) const;
@ -127,14 +127,14 @@ class FixedOrderedMultimap {
* *
* @warning The iterator needs to be valid and dereferenceable * @warning The iterator needs to be valid and dereferenceable
* @param[in/out] iter Pointer to iterator to the element that needs to be ereased * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
* @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this * @return returnvalue::OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
*/ */
ReturnValue_t erase(Iterator* iter); ReturnValue_t erase(Iterator* iter);
/*** /***
* Used to erase by key * Used to erase by key
* @param key Key to be erased * @param key Key to be erased
* @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this * @return returnvalue::OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
*/ */
ReturnValue_t erase(key_t key); ReturnValue_t erase(key_t key);
@ -160,7 +160,7 @@ class FixedOrderedMultimap {
* *
* @param key Key to search for * @param key Key to search for
* @param value Found value * @param value Found value
* @return RETURN_OK if it points to the value, * @return returnvalue::OK if it points to the value,
* KEY_DOES_NOT_EXIST if the key is not in the map * KEY_DOES_NOT_EXIST if the key is not in the map
*/ */
ReturnValue_t find(key_t key, T** value) const; ReturnValue_t find(key_t key, T** value) const;

@ -4,7 +4,7 @@
#include <cmath> #include <cmath>
#include "../globalfunctions/CRC.h" #include "../globalfunctions/CRC.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "../serialize/SerialArrayListAdapter.h" #include "../serialize/SerialArrayListAdapter.h"
#include "../serviceinterface/ServiceInterfaceStream.h" #include "../serviceinterface/ServiceInterfaceStream.h"
#include "ArrayList.h" #include "ArrayList.h"

@ -51,7 +51,7 @@ class PlacementFactory {
* This must be called by the user. * This must be called by the user.
* *
* @param thisElement Element to be destroyed * @param thisElement Element to be destroyed
* @return RETURN_OK if the element was destroyed, different errors on failure * @return returnvalue::OK if the element was destroyed, different errors on failure
*/ */
template <typename T> template <typename T>
ReturnValue_t destroy(T* thisElement) { ReturnValue_t destroy(T* thisElement) {

@ -3,7 +3,7 @@
#include <cstddef> #include <cstddef>
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
template <uint8_t N_READ_PTRS = 1> template <uint8_t N_READ_PTRS = 1>
class RingBufferBase { class RingBufferBase {

@ -47,7 +47,7 @@ class SimpleRingBuffer : public RingBufferBase<> {
* Write to circular buffer and increment write pointer by amount. * Write to circular buffer and increment write pointer by amount.
* @param data * @param data
* @param amount * @param amount
* @return -@c RETURN_OK if write operation was successful * @return -@c returnvalue::OK if write operation was successful
* -@c returnvalue::FAILED if * -@c returnvalue::FAILED if
*/ */
ReturnValue_t writeData(const uint8_t* data, size_t amount); ReturnValue_t writeData(const uint8_t* data, size_t amount);
@ -95,7 +95,7 @@ class SimpleRingBuffer : public RingBufferBase<> {
* If readRemaining was set to true, the true amount read will be assigned * If readRemaining was set to true, the true amount read will be assigned
* to the passed value. * to the passed value.
* @return * @return
* - @c RETURN_OK if data was read successfully * - @c returnvalue::OK if data was read successfully
* - @c returnvalue::FAILED if not enough data was available and readRemaining * - @c returnvalue::FAILED if not enough data was available and readRemaining
* was set to false. * was set to false.
*/ */

@ -7,7 +7,7 @@
#ifndef PLATFORM_WIN #ifndef PLATFORM_WIN
#include <sys/time.h> #include <sys/time.h>
#endif #endif
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw_contrib/sgp4/sgp4unit.h" #include "fsfw_contrib/sgp4/sgp4unit.h"
class Sgp4Propagator { class Sgp4Propagator {

@ -9,12 +9,12 @@
#define CCSDSRETURNVALUESIF_H_ #define CCSDSRETURNVALUESIF_H_
#include "dllConf.h" #include "dllConf.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
/** /**
* This is a helper class to collect special return values that come up during CCSDS Handling. * This is a helper class to collect special return values that come up during CCSDS Handling.
* @ingroup ccsds_handling * @ingroup ccsds_handling
*/ */
class CCSDSReturnValuesIF : public HasReturnvaluesIF { class CCSDSReturnValuesIF {
public: public:
static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER_IF; //!< Basic ID of the interface. static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER_IF; //!< Basic ID of the interface.

@ -51,7 +51,7 @@ class DataLinkLayer : public CCSDSReturnValuesIF {
* This method tries to process a frame that is placed in #frameBuffer. * This method tries to process a frame that is placed in #frameBuffer.
* The procedures described in the Standard are performed. * The procedures described in the Standard are performed.
* @param length Length of the incoming frame candidate. * @param length Length of the incoming frame candidate.
* @return @c RETURN_OK on successful handling, otherwise the return codes of the higher * @return @c returnvalue::OK on successful handling, otherwise the return codes of the higher
* methods. * methods.
*/ */
ReturnValue_t processFrame(uint16_t length); ReturnValue_t processFrame(uint16_t length);
@ -61,12 +61,12 @@ class DataLinkLayer : public CCSDSReturnValuesIF {
* handle Frames directed to this VC. * handle Frames directed to this VC.
* @param virtualChannelId Id of the VC. Shall be smaller than 64. * @param virtualChannelId Id of the VC. Shall be smaller than 64.
* @param object Reference to the object that handles the Frame. * @param object Reference to the object that handles the Frame.
* @return @c RETURN_OK on success, @c returnvalue::FAILED otherwise. * @return @c returnvalue::OK on success, @c returnvalue::FAILED otherwise.
*/ */
ReturnValue_t addVirtualChannel(uint8_t virtualChannelId, VirtualChannelReceptionIF* object); ReturnValue_t addVirtualChannel(uint8_t virtualChannelId, VirtualChannelReceptionIF* object);
/** /**
* The initialization method calls the @c initialize routine of all virtual channels. * The initialization method calls the @c initialize routine of all virtual channels.
* @return The return code of the first failed VC initialization or @c RETURN_OK. * @return The return code of the first failed VC initialization or @c returnvalue::OK.
*/ */
ReturnValue_t initialize(); ReturnValue_t initialize();
@ -91,19 +91,19 @@ class DataLinkLayer : public CCSDSReturnValuesIF {
virtualChannels; //!< Map of all virtual channels assigned. virtualChannels; //!< Map of all virtual channels assigned.
/** /**
* Method that performs all possible frame validity checks (as specified). * Method that performs all possible frame validity checks (as specified).
* @return Various error codes or @c RETURN_OK on success. * @return Various error codes or @c returnvalue::OK on success.
*/ */
ReturnValue_t frameValidationCheck(); ReturnValue_t frameValidationCheck();
/** /**
* First method to call. * First method to call.
* Removes start sequence bytes and checks if the complete frame was received. * Removes start sequence bytes and checks if the complete frame was received.
* SHOULDDO: Maybe handling the start sequence must be done more variable. * SHOULDDO: Maybe handling the start sequence must be done more variable.
* @return @c RETURN_OK or @c TOO_SHORT. * @return @c returnvalue::OK or @c TOO_SHORT.
*/ */
ReturnValue_t frameDelimitingAndFillRemoval(); ReturnValue_t frameDelimitingAndFillRemoval();
/** /**
* Small helper method to check the CRC of the Frame. * Small helper method to check the CRC of the Frame.
* @return @c RETURN_OK or @c CRC_FAILED. * @return @c returnvalue::OK or @c CRC_FAILED.
*/ */
ReturnValue_t frameCheckCRC(); ReturnValue_t frameCheckCRC();
/** /**

@ -37,8 +37,8 @@ class Farm1StateOpen : public Farm1StateIF {
* change to Farm1StateLockout. * change to Farm1StateLockout.
* @param frame The frame to handle. * @param frame The frame to handle.
* @param clcw Any changes to the CLCW shall be done with the help of this interface. * @param clcw Any changes to the CLCW shall be done with the help of this interface.
* @return If the Sequence Number is ok, it returns #RETURN_OK. Otherwise either #NS_POSITIVE_W, * @return If the Sequence Number is ok, it returns returnvalue::OK. Otherwise either
* #NS_NEGATIVE_W or NS_LOCKOUT is returned. * #NS_POSITIVE_W, #NS_NEGATIVE_W or NS_LOCKOUT is returned.
*/ */
ReturnValue_t handleADFrame(TcTransferFrame* frame, ClcwIF* clcw); ReturnValue_t handleADFrame(TcTransferFrame* frame, ClcwIF* clcw);
/** /**

@ -5,7 +5,7 @@
#include "dllConf.h" #include "dllConf.h"
#include "fsfw/ipc/MessageQueueSenderIF.h" #include "fsfw/ipc/MessageQueueSenderIF.h"
#include "fsfw/objectmanager/ObjectManagerIF.h" #include "fsfw/objectmanager/ObjectManagerIF.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
class StorageManagerIF; class StorageManagerIF;
@ -36,7 +36,7 @@ class MapPacketExtraction : public MapPacketExtractionIF {
* Method that is called if the segmentation flag is @c NO_SEGMENTATION. * Method that is called if the segmentation flag is @c NO_SEGMENTATION.
* The method extracts one or more packets within the frame and forwards them to the OBSW. * The method extracts one or more packets within the frame and forwards them to the OBSW.
* @param frame The TC Transfer Frame to work on. * @param frame The TC Transfer Frame to work on.
* @return @c RETURN_OK if all Packets were extracted. If something is entirely wrong, * @return @c returnvalue::OK if all Packets were extracted. If something is entirely wrong,
* @c DATA_CORRUPTED is returned, if some bytes are left over @c RESIDUAL_DATA. * @c DATA_CORRUPTED is returned, if some bytes are left over @c RESIDUAL_DATA.
*/ */
ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame); ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame);
@ -63,7 +63,7 @@ class MapPacketExtraction : public MapPacketExtractionIF {
ReturnValue_t extractPackets(TcTransferFrame* frame); ReturnValue_t extractPackets(TcTransferFrame* frame);
/** /**
* The #packetStore and the default destination of #tcQueue are initialized here. * The #packetStore and the default destination of #tcQueue are initialized here.
* @return @c RETURN_OK on success, @c returnvalue::FAILED otherwise. * @return @c returnvalue::OK on success, @c returnvalue::FAILED otherwise.
*/ */
ReturnValue_t initialize(); ReturnValue_t initialize();
/** /**

@ -77,7 +77,7 @@ class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSRe
* required. * required.
* @param frame The Tc Transfer Frame to handle. * @param frame The Tc Transfer Frame to handle.
* @param clcw Any changes on the CLCW shall be done with this method. * @param clcw Any changes on the CLCW shall be done with this method.
* @return Always returns @c RETURN_OK. * @return Always returns @c returnvalue::OK.
*/ */
ReturnValue_t handleBDFrame(TcTransferFrame* frame, ClcwIF* clcw); ReturnValue_t handleBDFrame(TcTransferFrame* frame, ClcwIF* clcw);
/** /**
@ -102,14 +102,14 @@ class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSRe
* Helper method to simplify adding a mapChannel during construction. * Helper method to simplify adding a mapChannel during construction.
* @param mapId The mapId of the object to add. * @param mapId The mapId of the object to add.
* @param object Pointer to the MapPacketExtraction object itself. * @param object Pointer to the MapPacketExtraction object itself.
* @return @c RETURN_OK if the channel was successfully inserted, @c returnvalue::FAILED * @return @c returnvalue::OK if the channel was successfully inserted, @c returnvalue::FAILED
* otherwise. * otherwise.
*/ */
ReturnValue_t addMapChannel(uint8_t mapId, MapPacketExtractionIF* object); ReturnValue_t addMapChannel(uint8_t mapId, MapPacketExtractionIF* object);
/** /**
* The initialization routine checks the set #slidingWindowWidth and initializes all MAP * The initialization routine checks the set #slidingWindowWidth and initializes all MAP
* channels. * channels.
* @return @c RETURN_OK on successful initialization, @c returnvalue::FAILED otherwise. * @return @c returnvalue::OK on successful initialization, @c returnvalue::FAILED otherwise.
*/ */
ReturnValue_t initialize(); ReturnValue_t initialize();
/** /**

@ -11,7 +11,7 @@
#include "ClcwIF.h" #include "ClcwIF.h"
#include "TcTransferFrame.h" #include "TcTransferFrame.h"
#include "dllConf.h" #include "dllConf.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
/** /**
* This is the interface for Virtual Channel reception classes. * This is the interface for Virtual Channel reception classes.
@ -33,13 +33,13 @@ class VirtualChannelReceptionIF {
* Handling the Frame includes forwarding to higher-level procedures. * Handling the Frame includes forwarding to higher-level procedures.
* @param frame The Tc Transfer Frame that was received and checked. * @param frame The Tc Transfer Frame that was received and checked.
* @param clcw Any changes to the CLCW value are forwarded by using this parameter. * @param clcw Any changes to the CLCW value are forwarded by using this parameter.
* @return The return Value shall indicate successful processing with @c RETURN_OK. * @return The return Value shall indicate successful processing with @c returnvalue::OK.
*/ */
virtual ReturnValue_t frameAcceptanceAndReportingMechanism(TcTransferFrame* frame, virtual ReturnValue_t frameAcceptanceAndReportingMechanism(TcTransferFrame* frame,
ClcwIF* clcw) = 0; ClcwIF* clcw) = 0;
/** /**
* If any other System Objects are required for operation they shall be initialized here. * If any other System Objects are required for operation they shall be initialized here.
* @return @c RETURN_OK for successful initialization. * @return @c returnvalue::OK for successful initialization.
*/ */
virtual ReturnValue_t initialize() = 0; virtual ReturnValue_t initialize() = 0;
/** /**

@ -1,7 +1,7 @@
#ifndef FSFW_DATAPOOL_DATASETIF_H_ #ifndef FSFW_DATAPOOL_DATASETIF_H_
#define FSFW_DATAPOOL_DATASETIF_H_ #define FSFW_DATAPOOL_DATASETIF_H_
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "../timemanager/Clock.h" #include "../timemanager/Clock.h"
class PoolVariableIF; class PoolVariableIF;

@ -58,7 +58,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
* freed afterwards. It is mandatory to call commit after a read call, * freed afterwards. It is mandatory to call commit after a read call,
* even if the read operation is not successful! * even if the read operation is not successful!
* @return * @return
* - @c RETURN_OK if all variables were read successfully. * - @c returnvalue::OK if all variables were read successfully.
* - @c INVALID_PARAMETER_DEFINITION if a pool entry does not exist or there * - @c INVALID_PARAMETER_DEFINITION if a pool entry does not exist or there
* is a type conflict. * is a type conflict.
* - @c SET_WAS_ALREADY_READ if read() is called twice without calling * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
@ -80,7 +80,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
* commit() can only be called after read(). If the set only contains * commit() can only be called after read(). If the set only contains
* variables which are write only, commit() can be called without a * variables which are write only, commit() can be called without a
* preceding read() call. Every read call must be followed by a commit call! * preceding read() call. Every read call must be followed by a commit call!
* @return - @c RETURN_OK if all variables were read successfully. * @return - @c returnvalue::OK if all variables were read successfully.
* - @c COMMITING_WITHOUT_READING if set was not read yet and * - @c COMMITING_WITHOUT_READING if set was not read yet and
* contains non write-only variables * contains non write-only variables
*/ */
@ -97,7 +97,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
/** /**
* Provides the means to lock the underlying data structure to ensure * Provides the means to lock the underlying data structure to ensure
* thread-safety. Default implementation is empty * thread-safety. Default implementation is empty
* @return Always returns -@c RETURN_OK * @return Always returns -@c returnvalue::OK
*/ */
virtual ReturnValue_t lockDataPool( virtual ReturnValue_t lockDataPool(
MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING, MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
@ -105,7 +105,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
/** /**
* Provides the means to unlock the underlying data structure to ensure * Provides the means to unlock the underlying data structure to ensure
* thread-safety. Default implementation is empty * thread-safety. Default implementation is empty
* @return Always returns -@c RETURN_OK * @return Always returns -@c returnvalue::OK
*/ */
virtual ReturnValue_t unlockDataPool() override; virtual ReturnValue_t unlockDataPool() override;

@ -1,7 +1,7 @@
#ifndef FSFW_DATAPOOL_POOLVARIABLEIF_H_ #ifndef FSFW_DATAPOOL_POOLVARIABLEIF_H_
#define FSFW_DATAPOOL_POOLVARIABLEIF_H_ #define FSFW_DATAPOOL_POOLVARIABLEIF_H_
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "../serialize/SerializeIF.h" #include "../serialize/SerializeIF.h"
#include "ReadCommitIF.h" #include "ReadCommitIF.h"

@ -2,7 +2,7 @@
#define FSFW_DATAPOOL_READCOMMITIF_H_ #define FSFW_DATAPOOL_READCOMMITIF_H_
#include "../ipc/MutexIF.h" #include "../ipc/MutexIF.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
/** /**
* @brief Common interface for all software objects which employ read-commit * @brief Common interface for all software objects which employ read-commit

@ -2,7 +2,7 @@
#define FSFW_DATAPOOL_READCOMMITIFATTORNEY_H_ #define FSFW_DATAPOOL_READCOMMITIFATTORNEY_H_
#include <fsfw/datapool/ReadCommitIF.h> #include <fsfw/datapool/ReadCommitIF.h>
#include <fsfw/returnvalues/HasReturnvaluesIF.h> #include <fsfw/returnvalues/returnvalue.h>
/** /**
* @brief This class determines which members are allowed to access protected members * @brief This class determines which members are allowed to access protected members

@ -4,7 +4,7 @@
#include "MarkChangedIF.h" #include "MarkChangedIF.h"
#include "fsfw/datapool/PoolVariableIF.h" #include "fsfw/datapool/PoolVariableIF.h"
#include "fsfw/objectmanager/SystemObjectIF.h" #include "fsfw/objectmanager/SystemObjectIF.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "localPoolDefinitions.h" #include "localPoolDefinitions.h"
class LocalDataPoolManager; class LocalDataPoolManager;

@ -4,7 +4,7 @@
#include "fsfw/housekeeping/AcceptsHkPacketsIF.h" #include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
#include "fsfw/ipc/MessageQueueIF.h" #include "fsfw/ipc/MessageQueueIF.h"
#include "fsfw/ipc/messageQueueDefinitions.h" #include "fsfw/ipc/messageQueueDefinitions.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "localPoolDefinitions.h" #include "localPoolDefinitions.h"
namespace subdp { namespace subdp {

@ -53,7 +53,7 @@ class AssemblyBase : public SubsystemBase {
* @param mode * @param mode
* @param submode * @param submode
* @return * @return
* - @c RETURN_OK if ok * - @c returnvalue::OK if ok
* - @c NEED_SECOND_STEP if children need to be commanded again * - @c NEED_SECOND_STEP if children need to be commanded again
*/ */
virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0; virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;

@ -1,7 +1,7 @@
#ifndef FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_ #ifndef FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_
#define FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_ #define FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "CookieIF.h" #include "CookieIF.h"
#include "DeviceHandlerIF.h" #include "DeviceHandlerIF.h"
/** /**
@ -61,7 +61,7 @@ class DeviceCommunicationIF {
* initialization. * initialization.
* @param cookie * @param cookie
* @return * @return
* - @c RETURN_OK if initialization was successfull * - @c returnvalue::OK if initialization was successfull
* - Everything else triggers failure event with returnvalue as parameter 1 * - Everything else triggers failure event with returnvalue as parameter 1
*/ */
virtual ReturnValue_t initializeInterface(CookieIF *cookie) = 0; virtual ReturnValue_t initializeInterface(CookieIF *cookie) = 0;
@ -74,7 +74,7 @@ class DeviceCommunicationIF {
* @param data * @param data
* @param len If this is 0, nothing shall be sent. * @param len If this is 0, nothing shall be sent.
* @return * @return
* - @c RETURN_OK for successfull send * - @c returnvalue::OK for successfull send
* - Everything else triggers failure event with returnvalue as parameter 1 * - Everything else triggers failure event with returnvalue as parameter 1
*/ */
virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) = 0; virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) = 0;
@ -84,7 +84,7 @@ class DeviceCommunicationIF {
* Get send confirmation that the data in sendMessage() was sent successfully. * Get send confirmation that the data in sendMessage() was sent successfully.
* @param cookie * @param cookie
* @return * @return
* - @c RETURN_OK if data was sent successfully but a reply is expected * - @c returnvalue::OK if data was sent successfully but a reply is expected
* - NO_REPLY_EXPECTED if data was sent successfully and no reply is expected * - NO_REPLY_EXPECTED if data was sent successfully and no reply is expected
* - Everything else to indicate failure * - Everything else to indicate failure
*/ */
@ -99,7 +99,7 @@ class DeviceCommunicationIF {
* *
* @param cookie * @param cookie
* @param requestLen Size of data to read * @param requestLen Size of data to read
* @return - @c RETURN_OK to confirm the request for data has been sent. * @return - @c returnvalue::OK to confirm the request for data has been sent.
* - Everything else triggers failure event with * - Everything else triggers failure event with
* returnvalue as parameter 1 * returnvalue as parameter 1
*/ */
@ -113,7 +113,7 @@ class DeviceCommunicationIF {
* @param buffer [out] Set reply here (by using *buffer = ...) * @param buffer [out] Set reply here (by using *buffer = ...)
* @param size [out] size pointer to set (by using *size = ...). * @param size [out] size pointer to set (by using *size = ...).
* Set to 0 if no reply was received * Set to 0 if no reply was received
* @return - @c RETURN_OK for successfull receive * @return - @c returnvalue::OK for successfull receive
* - @c NO_REPLY_RECEIVED if not reply was received. Setting size to * - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
* 0 has the same effect * 0 has the same effect
* - Everything else triggers failure event with * - Everything else triggers failure event with

@ -18,7 +18,7 @@
#include "fsfw/objectmanager/SystemObject.h" #include "fsfw/objectmanager/SystemObject.h"
#include "fsfw/parameters/ParameterHelper.h" #include "fsfw/parameters/ParameterHelper.h"
#include "fsfw/power/PowerSwitchIF.h" #include "fsfw/power/PowerSwitchIF.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/serviceinterface/serviceInterfaceDefintions.h" #include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
#include "fsfw/tasks/ExecutableObjectIF.h" #include "fsfw/tasks/ExecutableObjectIF.h"
@ -144,7 +144,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* 4. Decrements counter for timeout of replies by calling * 4. Decrements counter for timeout of replies by calling
* decrementDeviceReplyMap() * decrementDeviceReplyMap()
* 5. Performs FDIR check for failures * 5. Performs FDIR check for failures
* 6. If the device mode is MODE_OFF, return RETURN_OK. * 6. If the device mode is MODE_OFF, return returnvalue::OK.
* Otherwise, perform the Action property and performs depending * Otherwise, perform the Action property and performs depending
* on value specified by input value counter (incremented in PST). * on value specified by input value counter (incremented in PST).
* The child class tells base class what to do by setting this value. * The child class tells base class what to do by setting this value.
@ -160,7 +160,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* - GET_READ: Access requested reading data by calling doGetRead() * - GET_READ: Access requested reading data by calling doGetRead()
* which calls readReceivedMessage of #communicationInterface * which calls readReceivedMessage of #communicationInterface
* @param counter Specifies which Action to perform * @param counter Specifies which Action to perform
* @return RETURN_OK for successful execution * @return returnvalue::OK for successful execution
*/ */
virtual ReturnValue_t performOperation(uint8_t counter) override; virtual ReturnValue_t performOperation(uint8_t counter) override;
@ -281,7 +281,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* *
* @param[out] id the device command id that has been built * @param[out] id the device command id that has been built
* @return * @return
* - @c RETURN_OK to send command after setting #rawPacket and * - @c returnvalue::OK to send command after setting #rawPacket and
* #rawPacketLen. * #rawPacketLen.
* - @c NOTHING_TO_SEND when no command is to be sent. * - @c NOTHING_TO_SEND when no command is to be sent.
* - Anything else triggers an even with the returnvalue as a parameter. * - Anything else triggers an even with the returnvalue as a parameter.
@ -305,7 +305,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* *
* @param[out] id the device command id built * @param[out] id the device command id built
* @return * @return
* - @c RETURN_OK when a command is to be sent * - @c returnvalue::OK when a command is to be sent
* - @c NOTHING_TO_SEND when no command is to be sent * - @c NOTHING_TO_SEND when no command is to be sent
* - Anything else triggers an even with the returnvalue as a parameter * - Anything else triggers an even with the returnvalue as a parameter
*/ */
@ -327,7 +327,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* @param commandData Pointer to the data from the direct command * @param commandData Pointer to the data from the direct command
* @param commandDataLen Length of commandData * @param commandDataLen Length of commandData
* @return * @return
* - @c RETURN_OK to send command after #rawPacket and #rawPacketLen * - @c returnvalue::OK to send command after #rawPacket and #rawPacketLen
* have been set. * have been set.
* - @c HasActionsIF::EXECUTION_COMPLETE to generate a finish reply immediately. This can * - @c HasActionsIF::EXECUTION_COMPLETE to generate a finish reply immediately. This can
* be used if no reply is expected * be used if no reply is expected
@ -357,7 +357,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* @param[out] foundLen length of the data found. Is to be set in function, * @param[out] foundLen length of the data found. Is to be set in function,
* buffer is scanned at previous position + foundLen. * buffer is scanned at previous position + foundLen.
* @return * @return
* - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid * - @c returnvalue::OK a valid packet was found at @c start, @c foundLen is valid
* - @c returnvalue::FAILED no reply could be found starting at @c start, * - @c returnvalue::FAILED no reply could be found starting at @c start,
* implies @c foundLen is not valid, base class will call scanForReply() * implies @c foundLen is not valid, base class will call scanForReply()
* again with ++start * again with ++start
@ -387,7 +387,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* @param id the id found by scanForReply() * @param id the id found by scanForReply()
* @param packet * @param packet
* @return * @return
* - @c RETURN_OK when the reply was interpreted. * - @c returnvalue::OK when the reply was interpreted.
* - @c IGNORE_REPLY_DATA Ignore the reply and don't reset reply cycle * - @c IGNORE_REPLY_DATA Ignore the reply and don't reset reply cycle
* counter. * counter.
* - @c returnvalue::FAILED when the reply could not be interpreted, * - @c returnvalue::FAILED when the reply could not be interpreted,
@ -450,7 +450,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
* to provide a pointer to a Countdown object which will signal the timeout * to provide a pointer to a Countdown object which will signal the timeout
* when expired * when expired
* @return - @c RETURN_OK when the command was successfully inserted, * @return - @c returnvalue::OK when the command was successfully inserted,
* - @c returnvalue::FAILED else. * - @c returnvalue::FAILED else.
*/ */
ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles, ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
@ -471,7 +471,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
* to provide a pointer to a Countdown object which will signal the timeout * to provide a pointer to a Countdown object which will signal the timeout
* when expired * when expired
* @return - @c RETURN_OK when the command was successfully inserted, * @return - @c returnvalue::OK when the command was successfully inserted,
* - @c returnvalue::FAILED else. * - @c returnvalue::FAILED else.
*/ */
ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles, ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
@ -481,7 +481,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
/** /**
* @brief A simple command to add a command to the commandList. * @brief A simple command to add a command to the commandList.
* @param deviceCommand The command to add * @param deviceCommand The command to add
* @return - @c RETURN_OK when the command was successfully inserted, * @return - @c returnvalue::OK when the command was successfully inserted,
* - @c returnvalue::FAILED else. * - @c returnvalue::FAILED else.
*/ */
ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand, ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand,
@ -518,7 +518,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* @param periodic Indicates if the command is periodic (i.e. it is sent * @param periodic Indicates if the command is periodic (i.e. it is sent
* by the device repeatedly without request) or not. Default is aperiodic (0). * by the device repeatedly without request) or not. Default is aperiodic (0).
* Warning: The setting always overrides the value that was entered in the map. * Warning: The setting always overrides the value that was entered in the map.
* @return - @c RETURN_OK when the command was successfully inserted, * @return - @c returnvalue::OK when the command was successfully inserted,
* - @c returnvalue::FAILED else. * - @c returnvalue::FAILED else.
*/ */
ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply, uint16_t delayCycles, ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply, uint16_t delayCycles,
@ -602,7 +602,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* @param mode * @param mode
* @param submode * @param submode
* @return * @return
* - @c RETURN_OK if valid * - @c returnvalue::OK if valid
* - @c returnvalue::FAILED if invalid * - @c returnvalue::FAILED if invalid
*/ */
virtual ReturnValue_t isModeCombinationValid(Mode_t mode, Submode_t submode); virtual ReturnValue_t isModeCombinationValid(Mode_t mode, Submode_t submode);
@ -622,7 +622,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* @param[out] switches pointer to an array of switches * @param[out] switches pointer to an array of switches
* @param[out] numberOfSwitches length of returned array * @param[out] numberOfSwitches length of returned array
* @return * @return
* - @c RETURN_OK if the parameters were set * - @c returnvalue::OK if the parameters were set
* - @c returnvalue::FAILED if no switches exist * - @c returnvalue::FAILED if no switches exist
*/ */
virtual ReturnValue_t getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches); virtual ReturnValue_t getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches);
@ -977,7 +977,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* - A failure code may be returned if something went fundamentally wrong. * - A failure code may be returned if something went fundamentally wrong.
* *
* @param deviceCommand * @param deviceCommand
* @return - RETURN_OK if a reply was activated. * @return - returnvalue::OK if a reply was activated.
* - NO_REPLY_EXPECTED if there was no reply found. This is not an * - NO_REPLY_EXPECTED if there was no reply found. This is not an
* error case as many commands do not expect a reply. * error case as many commands do not expect a reply.
*/ */
@ -1004,7 +1004,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* *
* @param[out] id the device command id built * @param[out] id the device command id built
* @return * @return
* - @c RETURN_OK when a command is to be sent * - @c returnvalue::OK when a command is to be sent
* - not @c NOTHING_TO_SEND when no command is to be sent * - not @c NOTHING_TO_SEND when no command is to be sent
*/ */
virtual ReturnValue_t buildChildRawCommand(); virtual ReturnValue_t buildChildRawCommand();
@ -1085,7 +1085,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
/** /**
* Checks if current handler state allows reception of external device commands. * Checks if current handler state allows reception of external device commands.
* Default implementation allows commands only in plain MODE_ON and MODE_NORMAL. * Default implementation allows commands only in plain MODE_ON and MODE_NORMAL.
* @return RETURN_OK if commands are accepted, anything else otherwise. * @return returnvalue::OK if commands are accepted, anything else otherwise.
*/ */
virtual ReturnValue_t acceptExternalDeviceCommands(); virtual ReturnValue_t acceptExternalDeviceCommands();
@ -1273,9 +1273,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
* @param[out] data * @param[out] data
* @param[out] len * @param[out] len
* @return * @return
* - @c RETURN_OK @c data is valid * - @c returnvalue::OK @c data is valid
* - @c returnvalue::FAILED IPCStore is nullptr * - @c returnvalue::FAILED IPCStore is nullptr
* - the return value from the IPCStore if it was not @c RETURN_OK * - the return value from the IPCStore if it was not @c returnvalue::OK
*/ */
ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data, size_t *len); ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data, size_t *len);

@ -4,7 +4,7 @@
#include "../../container/PlacementFactory.h" #include "../../container/PlacementFactory.h"
#include "../../events/EventMessage.h" #include "../../events/EventMessage.h"
#include "../../globalfunctions/matching/MatchTree.h" #include "../../globalfunctions/matching/MatchTree.h"
#include "../../returnvalues/HasReturnvaluesIF.h" #include "../../returnvalues/returnvalue.h"
class StorageManagerIF; class StorageManagerIF;
class EventMatchTree : public MatchTree<EventMessage*> { class EventMatchTree : public MatchTree<EventMessage*> {

@ -2,7 +2,7 @@
#define FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_ #define FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
#include "../ipc/MessageQueueSenderIF.h" #include "../ipc/MessageQueueSenderIF.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
class ConfirmsFailuresIF { class ConfirmsFailuresIF {
public: public:

@ -5,7 +5,7 @@
#include "../health/HealthMessage.h" #include "../health/HealthMessage.h"
#include "../ipc/MessageQueueIF.h" #include "../ipc/MessageQueueIF.h"
#include "../parameters/HasParametersIF.h" #include "../parameters/HasParametersIF.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "ConfirmsFailuresIF.h" #include "ConfirmsFailuresIF.h"
#include "FaultCounter.h" #include "FaultCounter.h"

@ -1,7 +1,7 @@
#ifndef ASCIICONVERTER_H_ #ifndef ASCIICONVERTER_H_
#define ASCIICONVERTER_H_ #define ASCIICONVERTER_H_
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
class AsciiConverter { class AsciiConverter {
public: public:

@ -3,7 +3,7 @@
#include <cstddef> #include <cstddef>
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
/** /**
* @brief This DLE Encoder (Data Link Encoder) can be used to encode and * @brief This DLE Encoder (Data Link Encoder) can be used to encode and
@ -72,7 +72,7 @@ class DleEncoder {
* @param addStxEtx Adding STX start marker and ETX end marker can be omitted, * @param addStxEtx Adding STX start marker and ETX end marker can be omitted,
* if they are added manually * if they are added manually
* @return * @return
* - RETURN_OK for successful encoding operation * - returnvalue::OK for successful encoding operation
* - STREAM_TOO_SHORT if the destination stream is too short * - STREAM_TOO_SHORT if the destination stream is too short
*/ */
ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen, uint8_t *destStream, ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen, uint8_t *destStream,
@ -87,7 +87,7 @@ class DleEncoder {
* @param maxDestStreamlen * @param maxDestStreamlen
* @param decodedLen * @param decodedLen
* @return * @return
* - RETURN_OK for successful decode operation * - returnvalue::OK for successful decode operation
* - DECODE_ERROR if the source stream is invalid * - DECODE_ERROR if the source stream is invalid
* - STREAM_TOO_SHORT if the destination stream is too short * - STREAM_TOO_SHORT if the destination stream is too short
*/ */

@ -3,7 +3,7 @@
#include <type_traits> #include <type_traits>
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/serialize/SerializeIF.h" #include "fsfw/serialize/SerializeIF.h"
/** /**

@ -3,7 +3,7 @@
#include "../events/Event.h" #include "../events/Event.h"
#include "../ipc/MessageQueueSenderIF.h" #include "../ipc/MessageQueueSenderIF.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
class HasHealthIF { class HasHealthIF {
public: public:

@ -5,7 +5,7 @@
#include "../events/EventReportingProxyIF.h" #include "../events/EventReportingProxyIF.h"
#include "../ipc/MessageQueueIF.h" #include "../ipc/MessageQueueIF.h"
#include "../objectmanager/ObjectManagerIF.h" #include "../objectmanager/ObjectManagerIF.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "HasHealthIF.h" #include "HasHealthIF.h"
#include "HealthMessage.h" #include "HealthMessage.h"
#include "HealthTableIF.h" #include "HealthTableIF.h"
@ -55,7 +55,7 @@ class HealthHelper {
* *
* @param message * @param message
* @return * @return
* -@c RETURN_OK if the message was handled * -@c returnvalue::OK if the message was handled
* -@c returnvalue::FAILED if the message could not be handled * -@c returnvalue::FAILED if the message could not be handled
* (ie it was not a @c HEALTH_SET or @c HEALTH_READ message) * (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
*/ */
@ -88,7 +88,7 @@ class HealthHelper {
* @param parentQueue The queue ID of the parent object. * @param parentQueue The queue ID of the parent object.
* Set to 0 if no parent present * Set to 0 if no parent present
* @return * @return
* -@c RETURN_OK if the Health Table was found and the object * -@c returnvalue::OK if the Health Table was found and the object
* could be registered * could be registered
* -@c returnvalue::FAILED else * -@c returnvalue::FAILED else
*/ */

@ -4,7 +4,7 @@
#include <utility> #include <utility>
#include "../objectmanager/ObjectManagerIF.h" #include "../objectmanager/ObjectManagerIF.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "ManagesHealthIF.h" #include "ManagesHealthIF.h"
class HealthTableIF : public ManagesHealthIF { class HealthTableIF : public ManagesHealthIF {

@ -1,7 +1,7 @@
#ifndef FSFW_IPC_COMMANDMESSAGEIF_H_ #ifndef FSFW_IPC_COMMANDMESSAGEIF_H_
#define FSFW_IPC_COMMANDMESSAGEIF_H_ #define FSFW_IPC_COMMANDMESSAGEIF_H_
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "FwMessageTypes.h" #include "FwMessageTypes.h"
#include "MessageQueueMessageIF.h" #include "MessageQueueMessageIF.h"

@ -5,7 +5,7 @@
#include <cstdint> #include <cstdint>
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "MessageQueueMessageIF.h" #include "MessageQueueMessageIF.h"
#include "messageQueueDefinitions.h" #include "messageQueueDefinitions.h"
@ -40,7 +40,7 @@ class MessageQueueIF {
* @param message * @param message
* A pointer to a previously created message, which is sent. * A pointer to a previously created message, which is sent.
* @return * @return
* -@c RETURN_OK if ok * -@c returnvalue::OK if ok
* -@c NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found. * -@c NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found.
*/ */
virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0; virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0;
@ -69,14 +69,14 @@ class MessageQueueIF {
* function returns immediately. * function returns immediately.
* @param message * @param message
* A pointer to a message in which the received data is stored. * A pointer to a message in which the received data is stored.
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c MessageQueueIF::EMPTY if queue is empty * -@c MessageQueueIF::EMPTY if queue is empty
*/ */
virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0; virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
/** /**
* Deletes all pending messages in the queue. * Deletes all pending messages in the queue.
* @param count The number of flushed messages. * @param count The number of flushed messages.
* @return RETURN_OK on success. * @return returnvalue::OK on success.
*/ */
virtual ReturnValue_t flush(uint32_t* count) = 0; virtual ReturnValue_t flush(uint32_t* count) = 0;
/** /**
@ -104,7 +104,7 @@ class MessageQueueIF {
* @param ignoreFault * @param ignoreFault
* If set to true, the internal software fault counter is not incremented * If set to true, the internal software fault counter is not incremented
* if queue is full (if implemented). * if queue is full (if implemented).
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c MessageQueueIF::FULL if queue is full * -@c MessageQueueIF::FULL if queue is full
*/ */
virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message, virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
@ -136,7 +136,7 @@ class MessageQueueIF {
* @param sentFrom * @param sentFrom
* The sentFrom information can be set to inject the sender's queue id * The sentFrom information can be set to inject the sender's queue id
* into the message. This variable is set to zero by default. * into the message. This variable is set to zero by default.
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c MessageQueueIF::FULL if queue is full * -@c MessageQueueIF::FULL if queue is full
*/ */
virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom, virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
@ -148,7 +148,7 @@ class MessageQueueIF {
* call of the Implementation class and adds its queue id as * call of the Implementation class and adds its queue id as
* "sentFrom" information. * "sentFrom" information.
* @param message A pointer to a previously created message, which is sent. * @param message A pointer to a previously created message, which is sent.
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c MessageQueueIF::FULL if queue is full * -@c MessageQueueIF::FULL if queue is full
*/ */
virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message) = 0; virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message) = 0;

@ -1,7 +1,7 @@
#ifndef FRAMEWORK_IPC_MUTEXIF_H_ #ifndef FRAMEWORK_IPC_MUTEXIF_H_
#define FRAMEWORK_IPC_MUTEXIF_H_ #define FRAMEWORK_IPC_MUTEXIF_H_
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
/** /**
* @brief Common interface for OS Mutex objects which provide MUTual EXclusion. * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.

@ -6,7 +6,7 @@
#include "FileSystemArgsIF.h" #include "FileSystemArgsIF.h"
#include "fsfw/ipc/messageQueueDefinitions.h" #include "fsfw/ipc/messageQueueDefinitions.h"
#include "fsfw/returnvalues/FwClassIds.h" #include "fsfw/returnvalues/FwClassIds.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
/** /**
* @brief Generic interface for objects which expose a file system to enable * @brief Generic interface for objects which expose a file system to enable

@ -1,7 +1,7 @@
#ifndef HASMEMORYIF_H_ #ifndef HASMEMORYIF_H_
#define HASMEMORYIF_H_ #define HASMEMORYIF_H_
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
class HasMemoryIF { class HasMemoryIF {
public: public:

@ -3,7 +3,7 @@
#include "../ipc/CommandMessage.h" #include "../ipc/CommandMessage.h"
#include "../ipc/MessageQueueIF.h" #include "../ipc/MessageQueueIF.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "../storagemanager/StorageManagerIF.h" #include "../storagemanager/StorageManagerIF.h"
#include "AcceptsMemoryMessagesIF.h" #include "AcceptsMemoryMessagesIF.h"

@ -4,7 +4,7 @@
#include <cstdint> #include <cstdint>
#include "../events/Event.h" #include "../events/Event.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "ModeHelper.h" #include "ModeHelper.h"
#include "ModeMessage.h" #include "ModeMessage.h"

@ -3,7 +3,7 @@
#include "ModeMessage.h" #include "ModeMessage.h"
#include "fsfw/ipc/MessageQueueIF.h" #include "fsfw/ipc/MessageQueueIF.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/timemanager/Countdown.h" #include "fsfw/timemanager/Countdown.h"
class HasModesIF; class HasModesIF;

@ -8,7 +8,7 @@
#define LIMITVIOLATIONREPORTER_H_ #define LIMITVIOLATIONREPORTER_H_
#include "../ipc/MessageQueueSenderIF.h" #include "../ipc/MessageQueueSenderIF.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "../serialize/SerializeIF.h" #include "../serialize/SerializeIF.h"
#include "../storagemanager/StorageManagerIF.h" #include "../storagemanager/StorageManagerIF.h"
#include "monitoringConf.h" #include "monitoringConf.h"

@ -1,7 +1,7 @@
#ifndef FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_ #ifndef FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_
#define FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_ #define FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "../serviceinterface/ServiceInterface.h" #include "../serviceinterface/ServiceInterface.h"
#include "SystemObjectIF.h" #include "SystemObjectIF.h"
#include "frameworkObjects.h" #include "frameworkObjects.h"
@ -48,14 +48,14 @@ class ObjectManagerIF {
* @param id The new id to be added to the list. * @param id The new id to be added to the list.
* @param object A pointer to the object to be added. * @param object A pointer to the object to be added.
* @return @li INSERTION_FAILED in case the object could not be inserted. * @return @li INSERTION_FAILED in case the object could not be inserted.
* @li RETURN_OK in case the object was successfully inserted * @li returnvalue::OK in case the object was successfully inserted
*/ */
virtual ReturnValue_t insert(object_id_t id, SystemObjectIF* object) = 0; virtual ReturnValue_t insert(object_id_t id, SystemObjectIF* object) = 0;
/** /**
* @brief With this call, an object is removed from the list. * @brief With this call, an object is removed from the list.
* @param id The object id of the object to be removed. * @param id The object id of the object to be removed.
* @return @li NOT_FOUND in case the object was not found * @return @li NOT_FOUND in case the object was not found
* @li RETURN_OK in case the object was successfully removed * @li returnvalue::OK in case the object was successfully removed
*/ */
virtual ReturnValue_t remove(object_id_t id) = 0; virtual ReturnValue_t remove(object_id_t id) = 0;
virtual void initialize() = 0; virtual void initialize() = 0;

@ -4,7 +4,7 @@
#include <cstdint> #include <cstdint>
#include "../events/EventReportingProxyIF.h" #include "../events/EventReportingProxyIF.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
/** /**
* @defgroup system_objects Software System Object Management * @defgroup system_objects Software System Object Management
* The classes to create System Objects and classes to manage these are * The classes to create System Objects and classes to manage these are
@ -45,8 +45,8 @@ class SystemObjectIF : public EventReportingProxyIF {
* which might not have been built yet. * which might not have been built yet.
* Therefore, a two-step initialization resolves this problem and prevents * Therefore, a two-step initialization resolves this problem and prevents
* circular dependencies of not-fully initialized objects on start up. * circular dependencies of not-fully initialized objects on start up.
* @return - @c RETURN_OK in case the initialization was successful * @return - @c returnvalue::OK in case the initialization was successful
* - @c returnvalue::FAILED otherwise * - @c returnvalue::FAILED otherwise
*/ */
virtual ReturnValue_t initialize() = 0; virtual ReturnValue_t initialize() = 0;
/** /**
@ -54,7 +54,7 @@ class SystemObjectIF : public EventReportingProxyIF {
* for operation. * for operation.
* Some objects need certain other objects (or a certain number), to be * Some objects need certain other objects (or a certain number), to be
* registered as children. These checks can be done in this method. * registered as children. These checks can be done in this method.
* @return - @c RETURN_OK in case the check was successful * @return - @c returnvalue::OK in case the check was successful
* - @c any other code otherwise * - @c any other code otherwise
*/ */
virtual ReturnValue_t checkObjectConnections() = 0; virtual ReturnValue_t checkObjectConnections() = 0;

@ -1,7 +1,7 @@
#ifndef INTERNALERRORCODES_H_ #ifndef INTERNALERRORCODES_H_
#define INTERNALERRORCODES_H_ #define INTERNALERRORCODES_H_
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
class InternalErrorCodes { class InternalErrorCodes {
public: public:

@ -2,7 +2,7 @@
#define FSFW_OSAL_COMMON_TCPIPIF_H_ #define FSFW_OSAL_COMMON_TCPIPIF_H_
#include "../../platform.h" #include "../../platform.h"
#include "../../returnvalues/HasReturnvaluesIF.h" #include "../../returnvalues/returnvalue.h"
#ifdef PLATFORM_WIN #ifdef PLATFORM_WIN
#include <winsock2.h> #include <winsock2.h>

@ -2,7 +2,7 @@
#define FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ #define FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
#include "FreeRTOS.h" #include "FreeRTOS.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/tasks/SemaphoreIF.h" #include "fsfw/tasks/SemaphoreIF.h"
#include "task.h" #include "task.h"
@ -20,7 +20,7 @@
* (for example in the initializeAfterTaskCreation() function) or * (for example in the initializeAfterTaskCreation() function) or
* by calling refreshTaskHandle() with the correct executing task. * by calling refreshTaskHandle() with the correct executing task.
*/ */
class BinarySemaphoreUsingTask : public SemaphoreIF, public HasReturnvaluesIF { class BinarySemaphoreUsingTask : public SemaphoreIF {
public: public:
static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF; static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
@ -50,7 +50,7 @@ class BinarySemaphoreUsingTask : public SemaphoreIF, public HasReturnvaluesIF {
/** /**
* Same as acquire() with timeout in FreeRTOS ticks. * Same as acquire() with timeout in FreeRTOS ticks.
* @param timeoutTicks * @param timeoutTicks
* @return - @c RETURN_OK on success * @return - @c returnvalue::OK on success
* - @c returnvalue::FAILED on failure * - @c returnvalue::FAILED on failure
*/ */
ReturnValue_t acquireWithTickTimeout(TimeoutType timeoutType = TimeoutType::BLOCKING, ReturnValue_t acquireWithTickTimeout(TimeoutType timeoutType = TimeoutType::BLOCKING,
@ -65,7 +65,7 @@ class BinarySemaphoreUsingTask : public SemaphoreIF, public HasReturnvaluesIF {
/** /**
* Wrapper function to give back semaphore from handle * Wrapper function to give back semaphore from handle
* @param semaphore * @param semaphore
* @return - @c RETURN_OK on success * @return - @c returnvalue::OK on success
* - @c returnvalue::FAILED on failure * - @c returnvalue::FAILED on failure
*/ */
static ReturnValue_t release(TaskHandle_t taskToNotify); static ReturnValue_t release(TaskHandle_t taskToNotify);
@ -76,7 +76,7 @@ class BinarySemaphoreUsingTask : public SemaphoreIF, public HasReturnvaluesIF {
* @param higherPriorityTaskWoken This will be set to pdPASS if a task with * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
* a higher priority was unblocked. A context switch should be requested * a higher priority was unblocked. A context switch should be requested
* from an ISR if this is the case (see TaskManagement functions) * from an ISR if this is the case (see TaskManagement functions)
* @return - @c RETURN_OK on success * @return - @c returnvalue::OK on success
* - @c returnvalue::FAILED on failure * - @c returnvalue::FAILED on failure
*/ */
static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify, static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,

@ -2,7 +2,7 @@
#define FSFW_OSAL_FREERTOS_BINARYSEMPAHORE_H_ #define FSFW_OSAL_FREERTOS_BINARYSEMPAHORE_H_
#include "FreeRTOS.h" #include "FreeRTOS.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/tasks/SemaphoreIF.h" #include "fsfw/tasks/SemaphoreIF.h"
#include "semphr.h" #include "semphr.h"
@ -22,7 +22,7 @@
* @author R. Mueller * @author R. Mueller
* @ingroup osal * @ingroup osal
*/ */
class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF { class BinarySemaphore : public SemaphoreIF {
public: public:
static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF; static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
@ -47,7 +47,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
* for a maximum of #timeoutMs or until the semaphore is given back, * for a maximum of #timeoutMs or until the semaphore is given back,
* for example by an ISR or another task. * for example by an ISR or another task.
* @param timeoutMs * @param timeoutMs
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout * -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
*/ */
ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING, ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
@ -56,7 +56,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
/** /**
* Same as lockBinarySemaphore() with timeout in FreeRTOS ticks. * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
* @param timeoutTicks * @param timeoutTicks
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout * -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
*/ */
ReturnValue_t acquireWithTickTimeout(TimeoutType timeoutType = TimeoutType::BLOCKING, ReturnValue_t acquireWithTickTimeout(TimeoutType timeoutType = TimeoutType::BLOCKING,
@ -64,7 +64,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
/** /**
* Release the binary semaphore. * Release the binary semaphore.
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is * -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
* already available. * already available.
*/ */
@ -79,7 +79,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
/** /**
* Wrapper function to give back semaphore from handle * Wrapper function to give back semaphore from handle
* @param semaphore * @param semaphore
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is * -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
* already available. * already available.
*/ */
@ -91,7 +91,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
* @param higherPriorityTaskWoken This will be set to pdPASS if a task with * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
* a higher priority was unblocked. A context switch from an ISR should * a higher priority was unblocked. A context switch from an ISR should
* then be requested (see TaskManagement functions) * then be requested (see TaskManagement functions)
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is * -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
* already available. * already available.
*/ */

@ -30,7 +30,7 @@ class CountingSemaphoreUsingTask : public SemaphoreIF {
* for a maximum of #timeoutMs or until one is given back, * for a maximum of #timeoutMs or until one is given back,
* for example by an ISR or another task. * for example by an ISR or another task.
* @param timeoutMs * @param timeoutMs
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout * -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
*/ */
ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING, ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
@ -39,7 +39,7 @@ class CountingSemaphoreUsingTask : public SemaphoreIF {
/** /**
* Release a semaphore, increasing the number of available counting * Release a semaphore, increasing the number of available counting
* semaphores up to the #maxCount value. * semaphores up to the #maxCount value.
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are * -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
* already available. * already available.
*/ */
@ -59,7 +59,7 @@ class CountingSemaphoreUsingTask : public SemaphoreIF {
/** /**
* Acquire with a timeout value in ticks * Acquire with a timeout value in ticks
* @param timeoutTicks * @param timeoutTicks
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout * -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
*/ */
ReturnValue_t acquireWithTickTimeout(TimeoutType timeoutType = TimeoutType::BLOCKING, ReturnValue_t acquireWithTickTimeout(TimeoutType timeoutType = TimeoutType::BLOCKING,
@ -74,7 +74,7 @@ class CountingSemaphoreUsingTask : public SemaphoreIF {
/** /**
* Release semaphore of task by supplying task handle * Release semaphore of task by supplying task handle
* @param taskToNotify * @param taskToNotify
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are * -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
* already available. * already available.
*/ */
@ -85,7 +85,7 @@ class CountingSemaphoreUsingTask : public SemaphoreIF {
* @param higherPriorityTaskWoken This will be set to pdPASS if a task with * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
* a higher priority was unblocked. A context switch should be requested * a higher priority was unblocked. A context switch should be requested
* from an ISR if this is the case (see TaskManagement functions) * from an ISR if this is the case (see TaskManagement functions)
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are * -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
* already available. * already available.
*/ */

@ -2,7 +2,7 @@
#include "fsfw/osal/freertos/FixedTimeslotTask.h" #include "fsfw/osal/freertos/FixedTimeslotTask.h"
#include "fsfw/osal/freertos/PeriodicTask.h" #include "fsfw/osal/freertos/PeriodicTask.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
TaskFactory* TaskFactory::factoryInstance = new TaskFactory(); TaskFactory* TaskFactory::factoryInstance = new TaskFactory();

@ -3,7 +3,7 @@
#include <cstdint> #include <cstdint>
#include "../../returnvalues/HasReturnvaluesIF.h" #include "../../returnvalues/returnvalue.h"
#include "FreeRTOS.h" #include "FreeRTOS.h"
#include "task.h" #include "task.h"

@ -5,7 +5,7 @@
#include "fsfw/osal/host/FixedTimeslotTask.h" #include "fsfw/osal/host/FixedTimeslotTask.h"
#include "fsfw/osal/host/PeriodicTask.h" #include "fsfw/osal/host/PeriodicTask.h"
#include "fsfw/osal/host/taskHelpers.h" #include "fsfw/osal/host/taskHelpers.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/tasks/PeriodicTaskIF.h" #include "fsfw/tasks/PeriodicTaskIF.h"

@ -1,7 +1,7 @@
#ifndef FSFW_OSAL_HOST_TASKHELPERS_H_ #ifndef FSFW_OSAL_HOST_TASKHELPERS_H_
#define FSFW_OSAL_HOST_TASKHELPERS_H_ #define FSFW_OSAL_HOST_TASKHELPERS_H_
#include <fsfw/returnvalues/HasReturnvaluesIF.h> #include <fsfw/returnvalues/returnvalue.h>
#include <thread> #include <thread>

@ -1,7 +1,7 @@
#ifndef FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_ #ifndef FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
#define FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_ #define FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
#include "../../returnvalues/HasReturnvaluesIF.h" #include "../../returnvalues/returnvalue.h"
#include "../../tasks/SemaphoreIF.h" #include "../../tasks/SemaphoreIF.h"
extern "C" { extern "C" {
@ -17,7 +17,7 @@ extern "C" {
* @author R. Mueller * @author R. Mueller
* @ingroup osal * @ingroup osal
*/ */
class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF { class BinarySemaphore : public SemaphoreIF {
public: public:
static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF; static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
@ -45,7 +45,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
* for a maximum of #timeoutMs or until the semaphore is given back, * for a maximum of #timeoutMs or until the semaphore is given back,
* for example by an ISR or another task. * for example by an ISR or another task.
* @param timeoutMs * @param timeoutMs
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout * -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
*/ */
ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING, ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
@ -53,7 +53,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
/** /**
* Release the binary semaphore. * Release the binary semaphore.
* @return -@c RETURN_OK on success * @return -@c returnvalue::OK on success
* -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is * -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
* already available. * already available.
*/ */

@ -92,7 +92,7 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
// struct sysinfo sysInfo; // struct sysinfo sysInfo;
// int result = sysinfo(&sysInfo); // int result = sysinfo(&sysInfo);
// if(result != 0){ // if(result != 0){
// return HasReturnvaluesIF::returnvalue::FAILED; // return returnvalue::FAILED;
// } // }
// return sysInfo.uptime; // return sysInfo.uptime;
//} //}

@ -7,7 +7,7 @@
#include <cstdlib> #include <cstdlib>
#include "../../returnvalues/HasReturnvaluesIF.h" #include "../../returnvalues/returnvalue.h"
class PosixThread { class PosixThread {
public: public:

@ -2,7 +2,7 @@
#include "fsfw/osal/linux/FixedTimeslotTask.h" #include "fsfw/osal/linux/FixedTimeslotTask.h"
#include "fsfw/osal/linux/PeriodicPosixTask.h" #include "fsfw/osal/linux/PeriodicPosixTask.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/serviceinterface/ServiceInterface.h"
// TODO: Different variant than the lazy loading in QueueFactory. What's better and why? // TODO: Different variant than the lazy loading in QueueFactory. What's better and why?

@ -6,7 +6,7 @@
#include <rtems/rtems/types.h> #include <rtems/rtems/types.h>
#include "fsfw/osal/rtems/RtemsBasic.h" #include "fsfw/osal/rtems/RtemsBasic.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/serviceinterface/ServiceInterface.h"
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1

@ -8,7 +8,7 @@
#include <cstddef> #include <cstddef>
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
class RtemsBasic { class RtemsBasic {
public: public:

@ -3,7 +3,7 @@
#include "fsfw/osal/rtems/FixedTimeslotTask.h" #include "fsfw/osal/rtems/FixedTimeslotTask.h"
#include "fsfw/osal/rtems/PeriodicTask.h" #include "fsfw/osal/rtems/PeriodicTask.h"
#include "fsfw/osal/rtems/RtemsBasic.h" #include "fsfw/osal/rtems/RtemsBasic.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
// TODO: Different variant than the lazy loading in QueueFactory. What's better and why? // TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
TaskFactory* TaskFactory::factoryInstance = new TaskFactory(); TaskFactory* TaskFactory::factoryInstance = new TaskFactory();

@ -3,7 +3,7 @@
#include <cstdint> #include <cstdint>
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "ParameterWrapper.h" #include "ParameterWrapper.h"
/** /**

@ -4,7 +4,7 @@
#include <cstddef> #include <cstddef>
#include "../globalfunctions/Type.h" #include "../globalfunctions/Type.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "../serialize/SerializeAdapter.h" #include "../serialize/SerializeAdapter.h"
#include "../serialize/SerializeIF.h" #include "../serialize/SerializeIF.h"
@ -58,7 +58,7 @@ class ParameterWrapper : public SerializeIF {
* @param row * @param row
* @param column * @param column
* @return * @return
* -@c RETURN_OK if element was retrieved successfully * -@c returnvalue::OK if element was retrieved successfully
* -@c NOT_SET data has not been set yet * -@c NOT_SET data has not been set yet
* -@c DATATYPE_MISSMATCH Invalid supplied type * -@c DATATYPE_MISSMATCH Invalid supplied type
* -@c OUT_OF_BOUNDS Invalid row and/or column. * -@c OUT_OF_BOUNDS Invalid row and/or column.

@ -7,7 +7,7 @@
#include "../devicehandlers/HealthDevice.h" #include "../devicehandlers/HealthDevice.h"
#include "../monitoring/AbsLimitMonitor.h" #include "../monitoring/AbsLimitMonitor.h"
#include "../parameters/ParameterHelper.h" #include "../parameters/ParameterHelper.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "PowerComponentIF.h" #include "PowerComponentIF.h"
#include "PowerSwitchIF.h" #include "PowerSwitchIF.h"
namespace Factory { namespace Factory {

@ -2,7 +2,7 @@
#define FSFW_POWER_POWERSWITCHIF_H_ #define FSFW_POWER_POWERSWITCHIF_H_
#include "../events/Event.h" #include "../events/Event.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "definitions.h" #include "definitions.h"
/** /**
* *
@ -20,7 +20,7 @@ class PowerSwitchIF {
*/ */
virtual ~PowerSwitchIF() {} virtual ~PowerSwitchIF() {}
/** /**
* The Returnvalues id of this class, required by HasReturnvaluesIF * The Returnvalues id of this class
*/ */
static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCH_IF; static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCH_IF;
static const ReturnValue_t SWITCH_ON = MAKE_RETURN_CODE(1); static const ReturnValue_t SWITCH_ON = MAKE_RETURN_CODE(1);

@ -2,7 +2,7 @@
#define FSFW_POWER_POWERSWITCHER_H_ #define FSFW_POWER_POWERSWITCHER_H_
#include "../objectmanager/SystemObjectIF.h" #include "../objectmanager/SystemObjectIF.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "../timemanager/Countdown.h" #include "../timemanager/Countdown.h"
#include "PowerSwitchIF.h" #include "PowerSwitchIF.h"

@ -41,7 +41,7 @@ ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject(uint8_t subser
ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue( ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
MessageQueueId_t *messageQueueToSet, object_id_t *objectId) { MessageQueueId_t *messageQueueToSet, object_id_t *objectId) {
HasModesIF *destination = ObjectManager::instance()->get<HasModesIF>(*objectId); auto *destination = ObjectManager::instance()->get<HasModesIF>(*objectId);
if (destination == nullptr) { if (destination == nullptr) {
return CommandingServiceBase::INVALID_OBJECT; return CommandingServiceBase::INVALID_OBJECT;
} }

@ -37,12 +37,9 @@ class Service11TelecommandScheduling final : public PusServiceBase {
public: public:
static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_11; static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_11;
static constexpr ReturnValue_t INVALID_TYPE_TIME_WINDOW = static constexpr ReturnValue_t INVALID_TYPE_TIME_WINDOW = returnvalue::makeCode(CLASS_ID, 1);
HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1); static constexpr ReturnValue_t TIMESHIFTING_NOT_POSSIBLE = returnvalue::makeCode(CLASS_ID, 2);
static constexpr ReturnValue_t TIMESHIFTING_NOT_POSSIBLE = static constexpr ReturnValue_t INVALID_RELATIVE_TIME = returnvalue::makeCode(CLASS_ID, 3);
HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
static constexpr ReturnValue_t INVALID_RELATIVE_TIME =
HasReturnvaluesIF::makeReturnCode(CLASS_ID, 3);
static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_11; static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_11;
@ -122,31 +119,31 @@ class Service11TelecommandScheduling final : public PusServiceBase {
ReturnValue_t handleResetCommand(); ReturnValue_t handleResetCommand();
/** /**
* @brief Logic to be performed on an incoming TC[11,4]. * @brief Logic to be performed on an incoming TC[11,4].
* @return RETURN_OK if successful * @return returnvalue::OK if successful
*/ */
ReturnValue_t doInsertActivity(const uint8_t* data, size_t size); ReturnValue_t doInsertActivity(const uint8_t* data, size_t size);
/** /**
* @brief Logic to be performed on an incoming TC[11,5]. * @brief Logic to be performed on an incoming TC[11,5].
* @return RETURN_OK if successful * @return returnvalue::OK if successful
*/ */
ReturnValue_t doDeleteActivity(const uint8_t* data, size_t size); ReturnValue_t doDeleteActivity(const uint8_t* data, size_t size);
/** /**
* @brief Logic to be performed on an incoming TC[11,6]. * @brief Logic to be performed on an incoming TC[11,6].
* @return RETURN_OK if successful * @return returnvalue::OK if successful
*/ */
ReturnValue_t doFilterDeleteActivity(const uint8_t* data, size_t size); ReturnValue_t doFilterDeleteActivity(const uint8_t* data, size_t size);
/** /**
* @brief Logic to be performed on an incoming TC[11,7]. * @brief Logic to be performed on an incoming TC[11,7].
* @return RETURN_OK if successful * @return returnvalue::OK if successful
*/ */
ReturnValue_t doTimeshiftActivity(const uint8_t* data, size_t size); ReturnValue_t doTimeshiftActivity(const uint8_t* data, size_t size);
/** /**
* @brief Logic to be performed on an incoming TC[11,8]. * @brief Logic to be performed on an incoming TC[11,8].
* @return RETURN_OK if successful * @return returnvalue::OK if successful
*/ */
ReturnValue_t doFilterTimeshiftActivity(const uint8_t* data, size_t size); ReturnValue_t doFilterTimeshiftActivity(const uint8_t* data, size_t size);
@ -166,7 +163,7 @@ class Service11TelecommandScheduling final : public PusServiceBase {
* @param data Pointer to first byte described data * @param data Pointer to first byte described data
* @param dataSize Remaining size of data NOTE: non-const, this is modified by the function * @param dataSize Remaining size of data NOTE: non-const, this is modified by the function
* @param [out] requestId Request ID * @param [out] requestId Request ID
* @return RETURN_OK if successful * @return returnvalue::OK if successful
*/ */
ReturnValue_t getRequestIdFromData(const uint8_t*& data, size_t& dataSize, uint64_t& requestId); ReturnValue_t getRequestIdFromData(const uint8_t*& data, size_t& dataSize, uint64_t& requestId);
@ -185,7 +182,7 @@ class Service11TelecommandScheduling final : public PusServiceBase {
* @param dataSize TC data size * @param dataSize TC data size
* @param [out] itBegin Begin of filter range * @param [out] itBegin Begin of filter range
* @param [out] itEnd End of filter range * @param [out] itEnd End of filter range
* @return RETURN_OK if successful * @return returnvalue::OK if successful
*/ */
ReturnValue_t getMapFilterFromData(const uint8_t*& data, size_t& size, TcMapIter& itBegin, ReturnValue_t getMapFilterFromData(const uint8_t*& data, size_t& size, TcMapIter& itBegin,
TcMapIter& itEnd); TcMapIter& itEnd);

@ -3,7 +3,7 @@
#include "fsfw/ipc/MessageQueueIF.h" #include "fsfw/ipc/MessageQueueIF.h"
#include "fsfw/objectmanager/SystemObject.h" #include "fsfw/objectmanager/SystemObject.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/tasks/ExecutableObjectIF.h" #include "fsfw/tasks/ExecutableObjectIF.h"
#include "fsfw/tmtcservices/AcceptsVerifyMessageIF.h" #include "fsfw/tmtcservices/AcceptsVerifyMessageIF.h"
#include "fsfw/tmtcservices/PusVerificationReport.h" #include "fsfw/tmtcservices/PusVerificationReport.h"

@ -1,32 +1,8 @@
#ifndef FSFW_RETURNVALUES_RETURNVALUES_H_ #ifndef FSFW_RETURNVALUES_HASRETURNVALUES_IF_H_
#define FSFW_RETURNVALUES_RETURNVALUES_H_ #define FSFW_RETURNVALUES_HASRETURNVALUES_IF_H_
#include <returnvalues/classIds.h> #warning "This header is deprecated, please include returnvalue.h"
#include <cstdint> #include "returnvalue.h"
#include "FwClassIds.h" #endif /* FSFW_RETURNVALUES_HASRETURNVALUES_IF_H_ */
#define MAKE_RETURN_CODE(number) ((INTERFACE_ID << 8) + (number))
typedef uint16_t ReturnValue_t;
namespace returnvalue {
static const ReturnValue_t OK = 0;
static const ReturnValue_t FAILED = 1;
/**
* It is discouraged to use the input parameters 0,0 and 0,1 as this
* will generate the RETURN_OK and returnvalue::FAILED returnvalues.
* @param interfaceId
* @param number
* @return
*/
static constexpr ReturnValue_t makeCode(uint8_t classId, uint8_t number) {
return (static_cast<ReturnValue_t>(classId) << 8) + number;
}
} // namespace returnvalue
#endif /* FSFW_RETURNVALUES_RETURNVALUES_H_ */

@ -0,0 +1,31 @@
#ifndef FSFW_RETURNVALUES_RETURNVALUE_H_
#define FSFW_RETURNVALUES_RETURNVALUE_H_
#include <returnvalues/classIds.h>
#include <cstdint>
#include "FwClassIds.h"
#define MAKE_RETURN_CODE(number) ((INTERFACE_ID << 8) + (number))
typedef uint16_t ReturnValue_t;
namespace returnvalue {
static const ReturnValue_t OK = 0;
static const ReturnValue_t FAILED = 1;
/**
* It is discouraged to use the input parameters 0,0 and 0,1 as this
* will generate the returnvalue::OK and returnvalue::FAILED returnvalues.
* @param interfaceId
* @param number
* @return
*/
static constexpr ReturnValue_t makeCode(uint8_t classId, uint8_t number) {
return (static_cast<ReturnValue_t>(classId) << 8) + number;
}
} // namespace returnvalue
#endif /* FSFW_RETURNVALUES_RETURNVALUE_H_ */

@ -1,6 +1,6 @@
#ifndef FSFW_RETVAL_H #ifndef FSFW_RETVAL_H
#define FSFW_RETVAL_H #define FSFW_RETVAL_H
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#endif // FSFW_RETVAL_H #endif // FSFW_RETVAL_H

@ -1,7 +1,7 @@
#ifndef FSFW_RMAP_RMAP_H_ #ifndef FSFW_RMAP_RMAP_H_
#define FSFW_RMAP_RMAP_H_ #define FSFW_RMAP_RMAP_H_
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/rmap/RMAPCookie.h" #include "fsfw/rmap/RMAPCookie.h"
#include "rmapConf.h" #include "rmapConf.h"
@ -36,7 +36,7 @@
* assignment can be changed at runtime to allow for example redundancy switching. This API is * assignment can be changed at runtime to allow for example redundancy switching. This API is
* static as the information which channel to use is contained within the cookie. * static as the information which channel to use is contained within the cookie.
*/ */
class RMAP : public HasReturnvaluesIF { class RMAP {
public: public:
static const uint8_t INTERFACE_ID = CLASS_ID::RMAP_CHANNEL; static const uint8_t INTERFACE_ID = CLASS_ID::RMAP_CHANNEL;

@ -4,7 +4,7 @@
#include <cstddef> #include <cstddef>
#include "RMAPCookie.h" #include "RMAPCookie.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
#include "rmapConf.h" #include "rmapConf.h"
class RMAPChannelIF { class RMAPChannelIF {
@ -21,7 +21,7 @@ class RMAPChannelIF {
* @return * @return
* - @c LINK_DOWN when the link is down and all replies were missed * - @c LINK_DOWN when the link is down and all replies were missed
* - @c COMMAND_CHANNEL_DEACTIVATED if the channel's port is NULL * - @c COMMAND_CHANNEL_DEACTIVATED if the channel's port is NULL
* - @c RETURN_OK else * - @c returnvalue::OK else
*/ */
virtual ReturnValue_t reset() = 0; virtual ReturnValue_t reset() = 0;
@ -72,7 +72,7 @@ class RMAPChannelIF {
* @param data data to be sent * @param data data to be sent
* @param datalen length of data * @param datalen length of data
* @return * @return
* - @c RETURN_OK * - @c returnvalue::OK
* - @c COMMAND_NO_DESCRIPTORS_AVAILABLE no descriptors available for sending * - @c COMMAND_NO_DESCRIPTORS_AVAILABLE no descriptors available for sending
* command; command was not sent * command; command was not sent
* - @c COMMAND_BUFFER_FULL no receiver buffer available for * - @c COMMAND_BUFFER_FULL no receiver buffer available for

@ -25,7 +25,7 @@ class RmapDeviceCommunicationIF : public DeviceCommunicationIF {
* this can be performed in this function, which is called on device handler * this can be performed in this function, which is called on device handler
* initialization. * initialization.
* @param cookie * @param cookie
* @return -@c RETURN_OK if initialization was successfull * @return -@c returnvalue::OK if initialization was successfull
* - Everything else triggers failure event with returnvalue as parameter 1 * - Everything else triggers failure event with returnvalue as parameter 1
*/ */
virtual ReturnValue_t initializeInterface(CookieIF *cookie) = 0; virtual ReturnValue_t initializeInterface(CookieIF *cookie) = 0;
@ -37,7 +37,7 @@ class RmapDeviceCommunicationIF : public DeviceCommunicationIF {
* @param cookie * @param cookie
* @param data * @param data
* @param len * @param len
* @return -@c RETURN_OK for successfull send * @return -@c returnvalue::OK for successfull send
* - Everything else triggers failure event with returnvalue as parameter 1 * - Everything else triggers failure event with returnvalue as parameter 1
*/ */
virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen); virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen);
@ -46,7 +46,7 @@ class RmapDeviceCommunicationIF : public DeviceCommunicationIF {
* Called by DHB in the GET_WRITE doGetWrite(). * Called by DHB in the GET_WRITE doGetWrite().
* Get send confirmation that the data in sendMessage() was sent successfully. * Get send confirmation that the data in sendMessage() was sent successfully.
* @param cookie * @param cookie
* @return -@c RETURN_OK if data was sent successfull * @return -@c returnvalue::OK if data was sent successfull
* - Everything else triggers falure event with returnvalue as parameter 1 * - Everything else triggers falure event with returnvalue as parameter 1
*/ */
virtual ReturnValue_t getSendSuccess(CookieIF *cookie); virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
@ -57,7 +57,7 @@ class RmapDeviceCommunicationIF : public DeviceCommunicationIF {
* from a device. * from a device.
* *
* @param cookie * @param cookie
* @return -@c RETURN_OK to confirm the request for data has been sent. * @return -@c returnvalue::OK to confirm the request for data has been sent.
* -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage() * -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
* will not be called in the respective communication cycle. * will not be called in the respective communication cycle.
* - Everything else triggers failure event with returnvalue as parameter 1 * - Everything else triggers failure event with returnvalue as parameter 1
@ -71,7 +71,7 @@ class RmapDeviceCommunicationIF : public DeviceCommunicationIF {
* @param cookie * @param cookie
* @param data * @param data
* @param len * @param len
* @return @c RETURN_OK for successfull receive * @return @c returnvalue::OK for successfull receive
* - Everything else triggers failure event with returnvalue as parameter 1 * - Everything else triggers failure event with returnvalue as parameter 1
*/ */
virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size); virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size);

@ -4,7 +4,7 @@
#include <cstddef> #include <cstddef>
#include <type_traits> #include <type_traits>
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "EndianConverter.h" #include "EndianConverter.h"
#include "SerializeIF.h" #include "SerializeIF.h"
@ -40,7 +40,7 @@ class SerializeAdapter {
* @return * @return
* - @c BUFFER_TOO_SHORT The given buffer in is too short * - @c BUFFER_TOO_SHORT The given buffer in is too short
* - @c returnvalue::FAILED Generic Error * - @c returnvalue::FAILED Generic Error
* - @c RETURN_OK Successful serialization * - @c returnvalue::OK Successful serialization
*/ */
template <typename T> template <typename T>
static ReturnValue_t serialize(const T *object, uint8_t **buffer, size_t *size, size_t maxSize, static ReturnValue_t serialize(const T *object, uint8_t **buffer, size_t *size, size_t maxSize,
@ -65,7 +65,7 @@ class SerializeAdapter {
* @return * @return
* - @c BUFFER_TOO_SHORT The given buffer in is too short * - @c BUFFER_TOO_SHORT The given buffer in is too short
* - @c returnvalue::FAILED Generic Error * - @c returnvalue::FAILED Generic Error
* - @c RETURN_OK Successful serialization * - @c returnvalue::OK Successful serialization
*/ */
template <typename T> template <typename T>
static ReturnValue_t serialize(const T *object, uint8_t *const buffer, size_t *serSize, static ReturnValue_t serialize(const T *object, uint8_t *const buffer, size_t *serSize,
@ -114,7 +114,7 @@ class SerializeAdapter {
* - @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object * - @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object
* - @c TOO_MANY_ELEMENTS The buffer has more inputs than expected * - @c TOO_MANY_ELEMENTS The buffer has more inputs than expected
* - @c returnvalue::FAILED Generic Error * - @c returnvalue::FAILED Generic Error
* - @c RETURN_OK Successful deserialization * - @c returnvalue::OK Successful deserialization
*/ */
template <typename T> template <typename T>
static ReturnValue_t deSerialize(T *object, const uint8_t **buffer, size_t *size, static ReturnValue_t deSerialize(T *object, const uint8_t **buffer, size_t *size,
@ -137,7 +137,7 @@ class SerializeAdapter {
* - @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object * - @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object
* - @c TOO_MANY_ELEMENTS The buffer has more inputs than expected * - @c TOO_MANY_ELEMENTS The buffer has more inputs than expected
* - @c returnvalue::FAILED Generic Error * - @c returnvalue::FAILED Generic Error
* - @c RETURN_OK Successful deserialization * - @c returnvalue::OK Successful deserialization
*/ */
template <typename T> template <typename T>
static ReturnValue_t deSerialize(T *object, const uint8_t *buffer, size_t *deserSize, static ReturnValue_t deSerialize(T *object, const uint8_t *buffer, size_t *deserSize,

@ -3,7 +3,7 @@
#include <cstddef> #include <cstddef>
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/returnvalue.h"
/** /**
* @defgroup serialize Serialization * @defgroup serialize Serialization
@ -57,7 +57,7 @@ class SerializeIF {
* @return * @return
* - @c BUFFER_TOO_SHORT The given buffer in is too short * - @c BUFFER_TOO_SHORT The given buffer in is too short
* - @c returnvalue::FAILED Generic error * - @c returnvalue::FAILED Generic error
* - @c RETURN_OK Successful serialization * - @c returnvalue::OK Successful serialization
*/ */
[[nodiscard]] virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize, [[nodiscard]] virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
Endianness streamEndianness) const = 0; Endianness streamEndianness) const = 0;
@ -93,7 +93,7 @@ class SerializeIF {
* - @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object * - @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object
* - @c TOO_MANY_ELEMENTS The buffer has more inputs than expected * - @c TOO_MANY_ELEMENTS The buffer has more inputs than expected
* - @c returnvalue::FAILED Generic Error * - @c returnvalue::FAILED Generic Error
* - @c RETURN_OK Successful deserialization * - @c returnvalue::OK Successful deserialization
*/ */
virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size, virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
Endianness streamEndianness) = 0; Endianness streamEndianness) = 0;

@ -3,7 +3,7 @@
#include <FSFWConfig.h> #include <FSFWConfig.h>
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1

@ -3,7 +3,7 @@
#include <cstddef> #include <cstddef>
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "storeAddress.h" #include "storeAddress.h"
class StorageManagerIF; class StorageManagerIF;

@ -139,7 +139,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
* With this helper method, a free element of @c size is reserved. * With this helper method, a free element of @c size is reserved.
* @param size The minimum packet size that shall be reserved. * @param size The minimum packet size that shall be reserved.
* @param[out] address Storage ID of the reserved data. * @param[out] address Storage ID of the reserved data.
* @return - #RETURN_OK on success, * @return - returnvalue::OK on success,
* - the return codes of #getPoolIndex or #findEmpty otherwise. * - the return codes of #getPoolIndex or #findEmpty otherwise.
*/ */
virtual ReturnValue_t reserveSpace(const size_t size, store_address_t* address, bool ignoreFault); virtual ReturnValue_t reserveSpace(const size_t size, store_address_t* address, bool ignoreFault);
@ -211,7 +211,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
* fits is used. * fits is used.
* @param packet_size The size of the data to be stored. * @param packet_size The size of the data to be stored.
* @param[out] poolIndex The fitting pool index found. * @param[out] poolIndex The fitting pool index found.
* @return - @c RETURN_OK on success, * @return - @c returnvalue::OK on success,
* - @c DATA_TOO_LARGE otherwise. * - @c DATA_TOO_LARGE otherwise.
*/ */
ReturnValue_t getSubPoolIndex(size_t packetSize, uint16_t* subpoolIndex, ReturnValue_t getSubPoolIndex(size_t packetSize, uint16_t* subpoolIndex,
@ -231,7 +231,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
* duration grows with the fill level of the pool. * duration grows with the fill level of the pool.
* @param pool_index The pool in which the search is performed. * @param pool_index The pool in which the search is performed.
* @param[out] element The first found element in the pool. * @param[out] element The first found element in the pool.
* @return - #RETURN_OK on success, * @return - returnvalue::OK on success,
* - #DATA_STORAGE_FULL if the store is full * - #DATA_STORAGE_FULL if the store is full
*/ */
ReturnValue_t findEmpty(n_pool_elem_t poolIndex, uint16_t* element); ReturnValue_t findEmpty(n_pool_elem_t poolIndex, uint16_t* element);

@ -5,7 +5,7 @@
#include <utility> #include <utility>
#include "../events/Event.h" #include "../events/Event.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "StorageAccessor.h" #include "StorageAccessor.h"
#include "storeAddress.h" #include "storeAddress.h"
@ -63,9 +63,8 @@ class StorageManagerIF {
* @param storageId A pointer to the storageId to retrieve. * @param storageId A pointer to the storageId to retrieve.
* @param data The data to be stored in the StorageManager. * @param data The data to be stored in the StorageManager.
* @param size The amount of data to be stored. * @param size The amount of data to be stored.
* @return Returns @li RETURN_OK if data was added. * @return Returns @returnvalue::OK if data was added.
* @li returnvalue::FAILED if data could not be added. * @returnvalue::FAILED if data could not be added, storageId is unchanged then.
* storageId is unchanged then.
*/ */
virtual ReturnValue_t addData(store_address_t* storageId, const uint8_t* data, size_t size, virtual ReturnValue_t addData(store_address_t* storageId, const uint8_t* data, size_t size,
bool ignoreFault = false) = 0; bool ignoreFault = false) = 0;
@ -73,7 +72,7 @@ class StorageManagerIF {
* @brief With deleteData, the storageManager frees the memory region * @brief With deleteData, the storageManager frees the memory region
* identified by packet_id. * identified by packet_id.
* @param packet_id The identifier of the memory region to be freed. * @param packet_id The identifier of the memory region to be freed.
* @return @li RETURN_OK on success. * @return @li returnvalue::OK on success.
* @li returnvalue::FAILED if deletion did not work * @li returnvalue::FAILED if deletion did not work
* (e.g. an illegal packet_id was passed). * (e.g. an illegal packet_id was passed).
*/ */
@ -84,7 +83,7 @@ class StorageManagerIF {
* @param buffer Pointer to the data. * @param buffer Pointer to the data.
* @param size Size of data to be stored. * @param size Size of data to be stored.
* @param storeId Store id of the deleted element (optional) * @param storeId Store id of the deleted element (optional)
* @return @li RETURN_OK on success. * @return @li returnvalue::OK on success.
* @li failure code if deletion did not work * @li failure code if deletion did not work
*/ */
virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size, virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
@ -116,8 +115,8 @@ class StorageManagerIF {
* @param packet_ptr The passed pointer address is set to the the memory * @param packet_ptr The passed pointer address is set to the the memory
* position * position
* @param size The exact size of the stored data is returned here. * @param size The exact size of the stored data is returned here.
* @return @li RETURN_OK on success. * @return @returnvalue::OK on success.
* @li returnvalue::FAILED if fetching data did not work * @returnvalue::FAILED if fetching data did not work
* (e.g. an illegal packet_id was passed). * (e.g. an illegal packet_id was passed).
*/ */
virtual ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr, virtual ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
@ -156,9 +155,8 @@ class StorageManagerIF {
* @param storageId A pointer to the storageId to retrieve. * @param storageId A pointer to the storageId to retrieve.
* @param size The size of the space to be reserved. * @param size The size of the space to be reserved.
* @param p_data A pointer to the element data is returned here. * @param p_data A pointer to the element data is returned here.
* @return Returns @li RETURN_OK if data was added. * @return Returns @li returnvalue::OK if data was added.
* @li returnvalue::FAILED if data could not be added. * @returnvalue::FAILED if data could not be added, storageId is unchanged then.
* storageId is unchanged then.
*/ */
virtual ReturnValue_t getFreeElement(store_address_t* storageId, size_t size, uint8_t** p_data, virtual ReturnValue_t getFreeElement(store_address_t* storageId, size_t size, uint8_t** p_data,
bool ignoreFault = false) = 0; bool ignoreFault = false) = 0;

@ -223,14 +223,14 @@ ReturnValue_t SubsystemBase::handleModeReply(CommandMessage* message) {
return returnvalue::OK; return returnvalue::OK;
// case ModeMessage::CMD_MODE_COMMAND: // case ModeMessage::CMD_MODE_COMMAND:
// handleCommandedMode(message); // handleCommandedMode(message);
// return RETURN_OK; // return returnvalue::OK;
// case ModeMessage::CMD_MODE_ANNOUNCE: // case ModeMessage::CMD_MODE_ANNOUNCE:
// triggerEvent(MODE_INFO, mode, submode); // triggerEvent(MODE_INFO, mode, submode);
// return RETURN_OK; // return returnvalue::OK;
// case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY: // case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
// triggerEvent(MODE_INFO, mode, submode); // triggerEvent(MODE_INFO, mode, submode);
// commandAllChildren(message); // commandAllChildren(message);
// return RETURN_OK; // return returnvalue::OK;
default: default:
return returnvalue::FAILED; return returnvalue::FAILED;
} }

@ -9,7 +9,7 @@
#include "../ipc/MessageQueueIF.h" #include "../ipc/MessageQueueIF.h"
#include "../modes/HasModesIF.h" #include "../modes/HasModesIF.h"
#include "../objectmanager/SystemObject.h" #include "../objectmanager/SystemObject.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/returnvalue.h"
#include "../tasks/ExecutableObjectIF.h" #include "../tasks/ExecutableObjectIF.h"
#include "modes/HasModeSequenceIF.h" #include "modes/HasModeSequenceIF.h"
@ -42,7 +42,7 @@ class SubsystemBase : public SystemObject,
* Also adds them to the internal childrenMap. * Also adds them to the internal childrenMap.
* *
* @param objectId * @param objectId
* @return RETURN_OK if successful * @return returnvalue::OK if successful
* CHILD_DOESNT_HAVE_MODES if Child is no HasHealthIF and no HasModesIF * CHILD_DOESNT_HAVE_MODES if Child is no HasHealthIF and no HasModesIF
* COULD_NOT_INSERT_CHILD If the Child could not be added to the ChildrenMap * COULD_NOT_INSERT_CHILD If the Child could not be added to the ChildrenMap
*/ */

@ -7,7 +7,7 @@
#include "../../container/ArrayList.h" #include "../../container/ArrayList.h"
#include "../../container/SinglyLinkedList.h" #include "../../container/SinglyLinkedList.h"
#include "../../returnvalues/HasReturnvaluesIF.h" #include "../../returnvalues/returnvalue.h"
#include "ModeDefinitions.h" #include "ModeDefinitions.h"
class ModeStoreIF { class ModeStoreIF {

Some files were not shown because too many files have changed in this diff Show More