more occurences in comments
This commit is contained in:
parent
fc34d56239
commit
f63f3fa564
|
|
@ -35,7 +35,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
|
|||
- HAL Devicehandlers: Periodic printout is run-time configurable now
|
||||
- `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
|
||||
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
|
||||
- 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
|
||||
|
|
|
|||
|
|
@ -144,7 +144,7 @@ ReturnValue_t GyroHandler::initializeLocalDataPool(localpool::DataPool &localDat
|
|||
new PoolEntry<uint8_t>({0}));
|
||||
|
||||
poolManager.subscribeForPeriodicPacket(gyroData.getSid(), false, 4.0, false);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
return returnvalue::OK;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
@ -154,7 +154,7 @@ in any case:
|
|||
|
||||
```cpp
|
||||
PoolReadGuard readHelper(&gyroData);
|
||||
if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
|
||||
if(readHelper.getReadResult() == returnvalue::OK) {
|
||||
if(not gyroData.isValid()) {
|
||||
gyroData.setValidity(true, true);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -75,11 +75,11 @@ and the respective source file with sensible default return values:
|
|||
void TestDeviceHandler::doShutDown() {}
|
||||
|
||||
ReturnValue_t TestDeviceHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
ReturnValue_t TestDeviceHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
void TestDeviceHandler::fillCommandAndReplyMap() {}
|
||||
|
|
@ -87,17 +87,17 @@ and the respective source file with sensible default return values:
|
|||
ReturnValue_t TestDeviceHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
|
||||
const uint8_t* commandData,
|
||||
size_t commandDataLen) {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
ReturnValue_t TestDeviceHandler::scanForReply(const uint8_t* start, size_t remainingSize,
|
||||
DeviceCommandId_t* foundId, size_t* foundLen) {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
ReturnValue_t TestDeviceHandler::interpretDeviceReply(DeviceCommandId_t id,
|
||||
const uint8_t* packet) {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
||||
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,
|
||||
LocalDataPoolManager& poolManager) {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
return returnvalue::OK;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -150,7 +150,7 @@ with a housekeeping service command.
|
|||
new PoolEntry<uint8_t>({0}));
|
||||
|
||||
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,
|
||||
|
|
@ -160,7 +160,7 @@ in any case:
|
|||
.. code-block:: cpp
|
||||
|
||||
PoolReadGuard readHelper(&gyroData);
|
||||
if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
|
||||
if(readHelper.getReadResult() == returnvalue::OK) {
|
||||
if(not gyroData.isValid()) {
|
||||
gyroData.setValidity(true, true);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ class ActionHelper {
|
|||
* helper function
|
||||
* @param queueToUse_ Pointer to the messageQueue to be used, optional
|
||||
* if queue was set in constructor
|
||||
* @return Returns RETURN_OK if successful
|
||||
* @return Returns returnvalue::OK if successful
|
||||
*/
|
||||
ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
|
||||
/**
|
||||
|
|
@ -75,7 +75,7 @@ class ActionHelper {
|
|||
* message to
|
||||
* @param replyId ID of the executed command
|
||||
* @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,
|
||||
bool hideSender = false);
|
||||
|
|
@ -86,7 +86,7 @@ class ActionHelper {
|
|||
* message to
|
||||
* @param replyId ID of the executed command
|
||||
* @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,
|
||||
size_t dataSize, bool hideSender = false);
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ class HasActionsIF {
|
|||
*
|
||||
* @return
|
||||
* -@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,
|
||||
const uint8_t* data, size_t size) = 0;
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ class HeaderDeserializer : public RedirectableDataPointerIF, public PduHeaderIF
|
|||
/**
|
||||
* This needs to be called before accessing the PDU fields to avoid segmentation faults.
|
||||
* @return
|
||||
* - RETURN_OK on parse success
|
||||
* - returnvalue::OK on parse success
|
||||
* - returnvalue::FAILED Invalid raw data
|
||||
* - SerializeIF::BUFFER_TOO_SHORT if buffer is shorter than expected
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ class Tlv : public TlvIF {
|
|||
* @param maxSize
|
||||
* @param streamEndianness
|
||||
* @return
|
||||
* - RETURN_OK on success
|
||||
* - returnvalue::OK on success
|
||||
* - INVALID_TLV_TYPE
|
||||
* - SerializeIF returncode on wrong serialization parameters
|
||||
*/
|
||||
|
|
@ -37,7 +37,7 @@ class Tlv : public TlvIF {
|
|||
* @param buffer Raw buffer including the size field
|
||||
* @param size
|
||||
* @param streamEndianness
|
||||
* - RETURN_OK on success
|
||||
* - returnvalue::OK on success
|
||||
* - INVALID_TLV_TYPE
|
||||
* - SerializeIF returncode on wrong deserialization parameters
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -183,7 +183,7 @@ class ArrayList {
|
|||
* @param entry
|
||||
* @return
|
||||
* -@c FULL if the List is full
|
||||
* -@c RETURN_OK else
|
||||
* -@c returnvalue::OK else
|
||||
*/
|
||||
ReturnValue_t insert(T entry) {
|
||||
if (size >= maxSize_) {
|
||||
|
|
|
|||
|
|
@ -20,24 +20,24 @@ class FIFOBase {
|
|||
/**
|
||||
* Insert value into FIFO
|
||||
* @param value
|
||||
* @return RETURN_OK on success, FULL if full
|
||||
* @return returnvalue::OK on success, FULL if full
|
||||
*/
|
||||
ReturnValue_t insert(T value);
|
||||
/**
|
||||
* Retrieve item from FIFO. This removes the item from the FIFO.
|
||||
* @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);
|
||||
/**
|
||||
* Retrieve item from FIFO without removing it from FIFO.
|
||||
* @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);
|
||||
/**
|
||||
* Remove item from FIFO.
|
||||
* @return RETURN_OK on success, EMPTY if empty
|
||||
* @return returnvalue::OK on success, EMPTY if empty
|
||||
*/
|
||||
ReturnValue_t pop();
|
||||
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@ class FixedOrderedMultimap {
|
|||
* @param[in] value Value of the new element
|
||||
* @param[in/out] (optional) storedValue On success this points to the new value, otherwise a
|
||||
* 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);
|
||||
|
||||
|
|
@ -108,14 +108,14 @@ class FixedOrderedMultimap {
|
|||
* Used to insert new pair instead of single values
|
||||
*
|
||||
* @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);
|
||||
|
||||
/***
|
||||
* Can be used to check if a certain key is in the map
|
||||
* @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;
|
||||
|
||||
|
|
@ -127,14 +127,14 @@ class FixedOrderedMultimap {
|
|||
*
|
||||
* @warning The iterator needs to be valid and dereferenceable
|
||||
* @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);
|
||||
|
||||
/***
|
||||
* Used to erase by key
|
||||
* @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);
|
||||
|
||||
|
|
@ -160,7 +160,7 @@ class FixedOrderedMultimap {
|
|||
*
|
||||
* @param key Key to search for
|
||||
* @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
|
||||
*/
|
||||
ReturnValue_t find(key_t key, T** value) const;
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ class PlacementFactory {
|
|||
* This must be called by the user.
|
||||
*
|
||||
* @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>
|
||||
ReturnValue_t destroy(T* thisElement) {
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ class SimpleRingBuffer : public RingBufferBase<> {
|
|||
* Write to circular buffer and increment write pointer by amount.
|
||||
* @param data
|
||||
* @param amount
|
||||
* @return -@c RETURN_OK if write operation was successful
|
||||
* @return -@c returnvalue::OK if write operation was successful
|
||||
* -@c returnvalue::FAILED if
|
||||
*/
|
||||
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
|
||||
* to the passed value.
|
||||
* @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
|
||||
* was set to false.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ class DataLinkLayer : public CCSDSReturnValuesIF {
|
|||
* This method tries to process a frame that is placed in #frameBuffer.
|
||||
* The procedures described in the Standard are performed.
|
||||
* @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.
|
||||
*/
|
||||
ReturnValue_t processFrame(uint16_t length);
|
||||
|
|
@ -61,12 +61,12 @@ class DataLinkLayer : public CCSDSReturnValuesIF {
|
|||
* handle Frames directed to this VC.
|
||||
* @param virtualChannelId Id of the VC. Shall be smaller than 64.
|
||||
* @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);
|
||||
/**
|
||||
* 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();
|
||||
|
||||
|
|
@ -91,19 +91,19 @@ class DataLinkLayer : public CCSDSReturnValuesIF {
|
|||
virtualChannels; //!< Map of all virtual channels assigned.
|
||||
/**
|
||||
* 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();
|
||||
/**
|
||||
* First method to call.
|
||||
* Removes start sequence bytes and checks if the complete frame was received.
|
||||
* 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();
|
||||
/**
|
||||
* 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();
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ class Farm1StateOpen : public Farm1StateIF {
|
|||
* change to Farm1StateLockout.
|
||||
* @param frame The frame to handle.
|
||||
* @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_POSITIVE_W,
|
||||
* #NS_NEGATIVE_W or NS_LOCKOUT is returned.
|
||||
*/
|
||||
ReturnValue_t handleADFrame(TcTransferFrame* frame, ClcwIF* clcw);
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ class MapPacketExtraction : public MapPacketExtractionIF {
|
|||
* 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.
|
||||
* @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.
|
||||
*/
|
||||
ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame);
|
||||
|
|
@ -63,7 +63,7 @@ class MapPacketExtraction : public MapPacketExtractionIF {
|
|||
ReturnValue_t extractPackets(TcTransferFrame* frame);
|
||||
/**
|
||||
* 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();
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -77,7 +77,7 @@ class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSRe
|
|||
* required.
|
||||
* @param frame The Tc Transfer Frame to handle.
|
||||
* @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);
|
||||
/**
|
||||
|
|
@ -102,13 +102,13 @@ class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSRe
|
|||
* Helper method to simplify adding a mapChannel during construction.
|
||||
* @param mapId The mapId of the object to add.
|
||||
* @param object Pointer to the MapPacketExtraction object itself.
|
||||
* @return @c RETURN_OK if the channel was successfully inserted, @c returnvalue::FAILED otherwise.
|
||||
* @return @c returnvalue::OK if the channel was successfully inserted, @c returnvalue::FAILED otherwise.
|
||||
*/
|
||||
ReturnValue_t addMapChannel(uint8_t mapId, MapPacketExtractionIF* object);
|
||||
/**
|
||||
* The initialization routine checks the set #slidingWindowWidth and initializes all MAP
|
||||
* 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();
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -33,13 +33,13 @@ class VirtualChannelReceptionIF {
|
|||
* Handling the Frame includes forwarding to higher-level procedures.
|
||||
* @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.
|
||||
* @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,
|
||||
ClcwIF* clcw) = 0;
|
||||
/**
|
||||
* 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;
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
|
|||
* freed afterwards. It is mandatory to call commit after a read call,
|
||||
* even if the read operation is not successful!
|
||||
* @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
|
||||
* is a type conflict.
|
||||
* - @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
|
||||
* variables which are write only, commit() can be called without a
|
||||
* 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
|
||||
* 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
|
||||
* thread-safety. Default implementation is empty
|
||||
* @return Always returns -@c RETURN_OK
|
||||
* @return Always returns -@c returnvalue::OK
|
||||
*/
|
||||
virtual ReturnValue_t lockDataPool(
|
||||
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
|
||||
* thread-safety. Default implementation is empty
|
||||
* @return Always returns -@c RETURN_OK
|
||||
* @return Always returns -@c returnvalue::OK
|
||||
*/
|
||||
virtual ReturnValue_t unlockDataPool() override;
|
||||
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ class AssemblyBase : public SubsystemBase {
|
|||
* @param mode
|
||||
* @param submode
|
||||
* @return
|
||||
* - @c RETURN_OK if ok
|
||||
* - @c returnvalue::OK if ok
|
||||
* - @c NEED_SECOND_STEP if children need to be commanded again
|
||||
*/
|
||||
virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ class DeviceCommunicationIF {
|
|||
* initialization.
|
||||
* @param cookie
|
||||
* @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
|
||||
*/
|
||||
virtual ReturnValue_t initializeInterface(CookieIF *cookie) = 0;
|
||||
|
|
@ -74,7 +74,7 @@ class DeviceCommunicationIF {
|
|||
* @param data
|
||||
* @param len If this is 0, nothing shall be sent.
|
||||
* @return
|
||||
* - @c RETURN_OK for successfull send
|
||||
* - @c returnvalue::OK for successfull send
|
||||
* - Everything else triggers failure event with returnvalue as parameter 1
|
||||
*/
|
||||
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.
|
||||
* @param cookie
|
||||
* @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
|
||||
* - Everything else to indicate failure
|
||||
*/
|
||||
|
|
@ -99,7 +99,7 @@ class DeviceCommunicationIF {
|
|||
*
|
||||
* @param cookie
|
||||
* @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
|
||||
* returnvalue as parameter 1
|
||||
*/
|
||||
|
|
@ -113,7 +113,7 @@ class DeviceCommunicationIF {
|
|||
* @param buffer [out] Set reply here (by using *buffer = ...)
|
||||
* @param size [out] size pointer to set (by using *size = ...).
|
||||
* 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
|
||||
* 0 has the same effect
|
||||
* - Everything else triggers failure event with
|
||||
|
|
|
|||
|
|
@ -144,7 +144,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
|
|||
* 4. Decrements counter for timeout of replies by calling
|
||||
* decrementDeviceReplyMap()
|
||||
* 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
|
||||
* on value specified by input value counter (incremented in PST).
|
||||
* 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()
|
||||
* which calls readReceivedMessage of #communicationInterface
|
||||
* @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;
|
||||
|
||||
|
|
@ -281,7 +281,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
|
|||
*
|
||||
* @param[out] id the device command id that has been built
|
||||
* @return
|
||||
* - @c RETURN_OK to send command after setting #rawPacket and
|
||||
* - @c returnvalue::OK to send command after setting #rawPacket and
|
||||
* #rawPacketLen.
|
||||
* - @c NOTHING_TO_SEND when no command is to be sent.
|
||||
* - 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
|
||||
* @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
|
||||
* - 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 commandDataLen Length of commandData
|
||||
* @return
|
||||
* - @c RETURN_OK to send command after #rawPacket and #rawPacketLen
|
||||
* - @c returnvalue::OK to send command after #rawPacket and #rawPacketLen
|
||||
* have been set.
|
||||
* - @c HasActionsIF::EXECUTION_COMPLETE to generate a finish reply immediately. This can
|
||||
* 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,
|
||||
* buffer is scanned at previous position + foundLen.
|
||||
* @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,
|
||||
* implies @c foundLen is not valid, base class will call scanForReply()
|
||||
* again with ++start
|
||||
|
|
@ -387,7 +387,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
|
|||
* @param id the id found by scanForReply()
|
||||
* @param packet
|
||||
* @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
|
||||
* counter.
|
||||
* - @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
|
||||
* to provide a pointer to a Countdown object which will signal the timeout
|
||||
* 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.
|
||||
*/
|
||||
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
|
||||
* to provide a pointer to a Countdown object which will signal the timeout
|
||||
* 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.
|
||||
*/
|
||||
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.
|
||||
* @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.
|
||||
*/
|
||||
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
|
||||
* 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.
|
||||
* @return - @c RETURN_OK when the command was successfully inserted,
|
||||
* @return - @c returnvalue::OK when the command was successfully inserted,
|
||||
* - @c returnvalue::FAILED else.
|
||||
*/
|
||||
ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply, uint16_t delayCycles,
|
||||
|
|
@ -602,7 +602,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
|
|||
* @param mode
|
||||
* @param submode
|
||||
* @return
|
||||
* - @c RETURN_OK if valid
|
||||
* - @c returnvalue::OK if valid
|
||||
* - @c returnvalue::FAILED if invalid
|
||||
*/
|
||||
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] numberOfSwitches length of returned array
|
||||
* @return
|
||||
* - @c RETURN_OK if the parameters were set
|
||||
* - @c returnvalue::OK if the parameters were set
|
||||
* - @c returnvalue::FAILED if no switches exist
|
||||
*/
|
||||
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.
|
||||
*
|
||||
* @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
|
||||
* 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
|
||||
* @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
|
||||
*/
|
||||
virtual ReturnValue_t buildChildRawCommand();
|
||||
|
|
@ -1085,7 +1085,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
|
|||
/**
|
||||
* Checks if current handler state allows reception of external device commands.
|
||||
* 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();
|
||||
|
||||
|
|
@ -1273,9 +1273,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
|
|||
* @param[out] data
|
||||
* @param[out] len
|
||||
* @return
|
||||
* - @c RETURN_OK @c data is valid
|
||||
* - @c returnvalue::OK @c data is valid
|
||||
* - @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);
|
||||
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ class DleEncoder {
|
|||
* @param addStxEtx Adding STX start marker and ETX end marker can be omitted,
|
||||
* if they are added manually
|
||||
* @return
|
||||
* - RETURN_OK for successful encoding operation
|
||||
* - returnvalue::OK for successful encoding operation
|
||||
* - STREAM_TOO_SHORT if the destination stream is too short
|
||||
*/
|
||||
ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen, uint8_t *destStream,
|
||||
|
|
@ -87,7 +87,7 @@ class DleEncoder {
|
|||
* @param maxDestStreamlen
|
||||
* @param decodedLen
|
||||
* @return
|
||||
* - RETURN_OK for successful decode operation
|
||||
* - returnvalue::OK for successful decode operation
|
||||
* - DECODE_ERROR if the source stream is invalid
|
||||
* - STREAM_TOO_SHORT if the destination stream is too short
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ class HealthHelper {
|
|||
*
|
||||
* @param message
|
||||
* @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
|
||||
* (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.
|
||||
* Set to 0 if no parent present
|
||||
* @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
|
||||
* -@c returnvalue::FAILED else
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ class MessageQueueIF {
|
|||
* @param message
|
||||
* A pointer to a previously created message, which is sent.
|
||||
* @return
|
||||
* -@c RETURN_OK if ok
|
||||
* -@c returnvalue::OK if ok
|
||||
* -@c NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found.
|
||||
*/
|
||||
virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0;
|
||||
|
|
@ -69,14 +69,14 @@ class MessageQueueIF {
|
|||
* function returns immediately.
|
||||
* @param message
|
||||
* 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
|
||||
*/
|
||||
virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
|
||||
/**
|
||||
* Deletes all pending messages in the queue.
|
||||
* @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;
|
||||
/**
|
||||
|
|
@ -104,7 +104,7 @@ class MessageQueueIF {
|
|||
* @param ignoreFault
|
||||
* If set to true, the internal software fault counter is not incremented
|
||||
* 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
|
||||
*/
|
||||
virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
|
||||
|
|
@ -136,7 +136,7 @@ class MessageQueueIF {
|
|||
* @param sentFrom
|
||||
* The sentFrom information can be set to inject the sender's queue id
|
||||
* 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
|
||||
*/
|
||||
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
|
||||
* "sentFrom" information.
|
||||
* @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
|
||||
*/
|
||||
virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message) = 0;
|
||||
|
|
|
|||
|
|
@ -48,14 +48,14 @@ class ObjectManagerIF {
|
|||
* @param id The new id to be added to the list.
|
||||
* @param object A pointer to the object to be added.
|
||||
* @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;
|
||||
/**
|
||||
* @brief With this call, an object is removed from the list.
|
||||
* @param id The object id of the object to be removed.
|
||||
* @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 void initialize() = 0;
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ class SystemObjectIF : public EventReportingProxyIF {
|
|||
* which might not have been built yet.
|
||||
* Therefore, a two-step initialization resolves this problem and prevents
|
||||
* 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
|
||||
*/
|
||||
virtual ReturnValue_t initialize() = 0;
|
||||
|
|
@ -54,7 +54,7 @@ class SystemObjectIF : public EventReportingProxyIF {
|
|||
* for operation.
|
||||
* Some objects need certain other objects (or a certain number), to be
|
||||
* 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
|
||||
*/
|
||||
virtual ReturnValue_t checkObjectConnections() = 0;
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ class BinarySemaphoreUsingTask : public SemaphoreIF, public HasReturnvaluesIF {
|
|||
/**
|
||||
* Same as acquire() with timeout in FreeRTOS ticks.
|
||||
* @param timeoutTicks
|
||||
* @return - @c RETURN_OK on success
|
||||
* @return - @c returnvalue::OK on success
|
||||
* - @c returnvalue::FAILED on failure
|
||||
*/
|
||||
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
|
||||
* @param semaphore
|
||||
* @return - @c RETURN_OK on success
|
||||
* @return - @c returnvalue::OK on success
|
||||
* - @c returnvalue::FAILED on failure
|
||||
*/
|
||||
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
|
||||
* a higher priority was unblocked. A context switch should be requested
|
||||
* 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
|
||||
*/
|
||||
static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
|
|||
* for a maximum of #timeoutMs or until the semaphore is given back,
|
||||
* for example by an ISR or another task.
|
||||
* @param timeoutMs
|
||||
* @return -@c RETURN_OK on success
|
||||
* @return -@c returnvalue::OK on success
|
||||
* -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
|
||||
*/
|
||||
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.
|
||||
* @param timeoutTicks
|
||||
* @return -@c RETURN_OK on success
|
||||
* @return -@c returnvalue::OK on success
|
||||
* -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
|
||||
*/
|
||||
ReturnValue_t acquireWithTickTimeout(TimeoutType timeoutType = TimeoutType::BLOCKING,
|
||||
|
|
@ -64,7 +64,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
|
|||
|
||||
/**
|
||||
* 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
|
||||
* already available.
|
||||
*/
|
||||
|
|
@ -79,7 +79,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
|
|||
/**
|
||||
* Wrapper function to give back semaphore from handle
|
||||
* @param semaphore
|
||||
* @return -@c RETURN_OK on success
|
||||
* @return -@c returnvalue::OK on success
|
||||
* -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
|
||||
* already available.
|
||||
*/
|
||||
|
|
@ -91,7 +91,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
|
|||
* @param higherPriorityTaskWoken This will be set to pdPASS if a task with
|
||||
* a higher priority was unblocked. A context switch from an ISR should
|
||||
* 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
|
||||
* already available.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ class CountingSemaphoreUsingTask : public SemaphoreIF {
|
|||
* for a maximum of #timeoutMs or until one is given back,
|
||||
* for example by an ISR or another task.
|
||||
* @param timeoutMs
|
||||
* @return -@c RETURN_OK on success
|
||||
* @return -@c returnvalue::OK on success
|
||||
* -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
|
||||
*/
|
||||
ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
|
||||
|
|
@ -39,7 +39,7 @@ class CountingSemaphoreUsingTask : public SemaphoreIF {
|
|||
/**
|
||||
* Release a semaphore, increasing the number of available counting
|
||||
* 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
|
||||
* already available.
|
||||
*/
|
||||
|
|
@ -59,7 +59,7 @@ class CountingSemaphoreUsingTask : public SemaphoreIF {
|
|||
/**
|
||||
* Acquire with a timeout value in ticks
|
||||
* @param timeoutTicks
|
||||
* @return -@c RETURN_OK on success
|
||||
* @return -@c returnvalue::OK on success
|
||||
* -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
|
||||
*/
|
||||
ReturnValue_t acquireWithTickTimeout(TimeoutType timeoutType = TimeoutType::BLOCKING,
|
||||
|
|
@ -74,7 +74,7 @@ class CountingSemaphoreUsingTask : public SemaphoreIF {
|
|||
/**
|
||||
* Release semaphore of task by supplying task handle
|
||||
* @param taskToNotify
|
||||
* @return -@c RETURN_OK on success
|
||||
* @return -@c returnvalue::OK on success
|
||||
* -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
|
||||
* already available.
|
||||
*/
|
||||
|
|
@ -85,7 +85,7 @@ class CountingSemaphoreUsingTask : public SemaphoreIF {
|
|||
* @param higherPriorityTaskWoken This will be set to pdPASS if a task with
|
||||
* a higher priority was unblocked. A context switch should be requested
|
||||
* 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
|
||||
* already available.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
|
|||
* for a maximum of #timeoutMs or until the semaphore is given back,
|
||||
* for example by an ISR or another task.
|
||||
* @param timeoutMs
|
||||
* @return -@c RETURN_OK on success
|
||||
* @return -@c returnvalue::OK on success
|
||||
* -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
|
||||
*/
|
||||
ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
|
||||
|
|
@ -53,7 +53,7 @@ class BinarySemaphore : public SemaphoreIF, public HasReturnvaluesIF {
|
|||
|
||||
/**
|
||||
* 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
|
||||
* already available.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ class ParameterWrapper : public SerializeIF {
|
|||
* @param row
|
||||
* @param column
|
||||
* @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 DATATYPE_MISSMATCH Invalid supplied type
|
||||
* -@c OUT_OF_BOUNDS Invalid row and/or column.
|
||||
|
|
|
|||
|
|
@ -123,31 +123,31 @@ class Service11TelecommandScheduling final : public PusServiceBase {
|
|||
ReturnValue_t handleResetCommand();
|
||||
/**
|
||||
* @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);
|
||||
|
||||
/**
|
||||
* @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);
|
||||
|
||||
/**
|
||||
* @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);
|
||||
|
||||
/**
|
||||
* @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);
|
||||
|
||||
/**
|
||||
* @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);
|
||||
|
||||
|
|
@ -167,7 +167,7 @@ class Service11TelecommandScheduling final : public PusServiceBase {
|
|||
* @param data Pointer to first byte described data
|
||||
* @param dataSize Remaining size of data NOTE: non-const, this is modified by the function
|
||||
* @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);
|
||||
|
||||
|
|
@ -186,7 +186,7 @@ class Service11TelecommandScheduling final : public PusServiceBase {
|
|||
* @param dataSize TC data size
|
||||
* @param [out] itBegin Begin 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,
|
||||
TcMapIter& itEnd);
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ namespace returnvalue {
|
|||
|
||||
/**
|
||||
* It is discouraged to use the input parameters 0,0 and 0,1 as this
|
||||
* will generate the RETURN_OK and returnvalue::FAILED returnvalues.
|
||||
* will generate the returnvalue::OK and returnvalue::FAILED returnvalues.
|
||||
* @param interfaceId
|
||||
* @param number
|
||||
* @return
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ class RMAPChannelIF {
|
|||
* @return
|
||||
* - @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 RETURN_OK else
|
||||
* - @c returnvalue::OK else
|
||||
*/
|
||||
virtual ReturnValue_t reset() = 0;
|
||||
|
||||
|
|
@ -72,7 +72,7 @@ class RMAPChannelIF {
|
|||
* @param data data to be sent
|
||||
* @param datalen length of data
|
||||
* @return
|
||||
* - @c RETURN_OK
|
||||
* - @c returnvalue::OK
|
||||
* - @c COMMAND_NO_DESCRIPTORS_AVAILABLE no descriptors available for sending
|
||||
* command; command was not sent
|
||||
* - @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
|
||||
* initialization.
|
||||
* @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
|
||||
*/
|
||||
virtual ReturnValue_t initializeInterface(CookieIF *cookie) = 0;
|
||||
|
|
@ -37,7 +37,7 @@ class RmapDeviceCommunicationIF : public DeviceCommunicationIF {
|
|||
* @param cookie
|
||||
* @param data
|
||||
* @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
|
||||
*/
|
||||
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().
|
||||
* Get send confirmation that the data in sendMessage() was sent successfully.
|
||||
* @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
|
||||
*/
|
||||
virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
|
||||
|
|
@ -57,7 +57,7 @@ class RmapDeviceCommunicationIF : public DeviceCommunicationIF {
|
|||
* from a device.
|
||||
*
|
||||
* @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()
|
||||
* will not be called in the respective communication cycle.
|
||||
* - Everything else triggers failure event with returnvalue as parameter 1
|
||||
|
|
@ -71,7 +71,7 @@ class RmapDeviceCommunicationIF : public DeviceCommunicationIF {
|
|||
* @param cookie
|
||||
* @param data
|
||||
* @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
|
||||
*/
|
||||
virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size);
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ class SerializeAdapter {
|
|||
* @return
|
||||
* - @c BUFFER_TOO_SHORT The given buffer in is too short
|
||||
* - @c returnvalue::FAILED Generic Error
|
||||
* - @c RETURN_OK Successful serialization
|
||||
* - @c returnvalue::OK Successful serialization
|
||||
*/
|
||||
template <typename T>
|
||||
static ReturnValue_t serialize(const T *object, uint8_t **buffer, size_t *size, size_t maxSize,
|
||||
|
|
@ -65,7 +65,7 @@ class SerializeAdapter {
|
|||
* @return
|
||||
* - @c BUFFER_TOO_SHORT The given buffer in is too short
|
||||
* - @c returnvalue::FAILED Generic Error
|
||||
* - @c RETURN_OK Successful serialization
|
||||
* - @c returnvalue::OK Successful serialization
|
||||
*/
|
||||
template <typename T>
|
||||
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 TOO_MANY_ELEMENTS The buffer has more inputs than expected
|
||||
* - @c returnvalue::FAILED Generic Error
|
||||
* - @c RETURN_OK Successful deserialization
|
||||
* - @c returnvalue::OK Successful deserialization
|
||||
*/
|
||||
template <typename T>
|
||||
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 TOO_MANY_ELEMENTS The buffer has more inputs than expected
|
||||
* - @c returnvalue::FAILED Generic Error
|
||||
* - @c RETURN_OK Successful deserialization
|
||||
* - @c returnvalue::OK Successful deserialization
|
||||
*/
|
||||
template <typename T>
|
||||
static ReturnValue_t deSerialize(T *object, const uint8_t *buffer, size_t *deserSize,
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ class SerializeIF {
|
|||
* @return
|
||||
* - @c BUFFER_TOO_SHORT The given buffer in is too short
|
||||
* - @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,
|
||||
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 TOO_MANY_ELEMENTS The buffer has more inputs than expected
|
||||
* - @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,
|
||||
Endianness streamEndianness) = 0;
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
|
|||
* With this helper method, a free element of @c size is reserved.
|
||||
* @param size The minimum packet size that shall be reserved.
|
||||
* @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.
|
||||
*/
|
||||
virtual ReturnValue_t reserveSpace(const size_t size, store_address_t* address, bool ignoreFault);
|
||||
|
|
@ -210,7 +210,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
|
|||
* fits is used.
|
||||
* @param packet_size The size of the data to be stored.
|
||||
* @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.
|
||||
*/
|
||||
ReturnValue_t getSubPoolIndex(size_t packetSize, uint16_t* subpoolIndex,
|
||||
|
|
@ -230,7 +230,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
|
|||
* duration grows with the fill level of the pool.
|
||||
* @param pool_index The pool in which the search is performed.
|
||||
* @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
|
||||
*/
|
||||
ReturnValue_t findEmpty(n_pool_elem_t poolIndex, uint16_t* element);
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ class StorageManagerIF {
|
|||
* @param storageId A pointer to the storageId to retrieve.
|
||||
* @param data The data to be stored in the StorageManager.
|
||||
* @param size The amount of data to be stored.
|
||||
* @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.
|
||||
* storageId is unchanged then.
|
||||
*/
|
||||
|
|
@ -73,7 +73,7 @@ class StorageManagerIF {
|
|||
* @brief With deleteData, the storageManager frees the memory region
|
||||
* identified by packet_id.
|
||||
* @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
|
||||
* (e.g. an illegal packet_id was passed).
|
||||
*/
|
||||
|
|
@ -84,7 +84,7 @@ class StorageManagerIF {
|
|||
* @param buffer Pointer to the data.
|
||||
* @param size Size of data to be stored.
|
||||
* @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
|
||||
*/
|
||||
virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
|
||||
|
|
@ -116,7 +116,7 @@ class StorageManagerIF {
|
|||
* @param packet_ptr The passed pointer address is set to the the memory
|
||||
* position
|
||||
* @param size The exact size of the stored data is returned here.
|
||||
* @return @li RETURN_OK on success.
|
||||
* @return @li returnvalue::OK on success.
|
||||
* @li returnvalue::FAILED if fetching data did not work
|
||||
* (e.g. an illegal packet_id was passed).
|
||||
*/
|
||||
|
|
@ -156,7 +156,7 @@ class StorageManagerIF {
|
|||
* @param storageId A pointer to the storageId to retrieve.
|
||||
* @param size The size of the space to be reserved.
|
||||
* @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.
|
||||
* storageId is unchanged then.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -223,14 +223,14 @@ ReturnValue_t SubsystemBase::handleModeReply(CommandMessage* message) {
|
|||
return returnvalue::OK;
|
||||
// case ModeMessage::CMD_MODE_COMMAND:
|
||||
// handleCommandedMode(message);
|
||||
// return RETURN_OK;
|
||||
// return returnvalue::OK;
|
||||
// case ModeMessage::CMD_MODE_ANNOUNCE:
|
||||
// triggerEvent(MODE_INFO, mode, submode);
|
||||
// return RETURN_OK;
|
||||
// return returnvalue::OK;
|
||||
// case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
|
||||
// triggerEvent(MODE_INFO, mode, submode);
|
||||
// commandAllChildren(message);
|
||||
// return RETURN_OK;
|
||||
// return returnvalue::OK;
|
||||
default:
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ class SubsystemBase : public SystemObject,
|
|||
* Also adds them to the internal childrenMap.
|
||||
*
|
||||
* @param objectId
|
||||
* @return RETURN_OK if successful
|
||||
* @return returnvalue::OK if successful
|
||||
* 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
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ FixedSlotSequence::~FixedSlotSequence() {
|
|||
|
||||
void FixedSlotSequence::executeAndAdvance() {
|
||||
current->executableObject->performOperation(current->opcode);
|
||||
// if (returnValue != RETURN_OK) {
|
||||
// if (returnValue != returnvalue::OK) {
|
||||
// this->sendErrorMessage( returnValue );
|
||||
// }
|
||||
// Increment the polling Sequence iterator
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ class PeriodicTaskIF {
|
|||
* The objects are executed in the order added. The object needs to implement
|
||||
* ExecutableObjectIF
|
||||
* @param object Id of the object to add.
|
||||
* @return RETURN_OK on success, returnvalue::FAILED if the object could not be added.
|
||||
* @return returnvalue::OK on success, returnvalue::FAILED if the object could not be added.
|
||||
*/
|
||||
virtual ReturnValue_t addComponent(object_id_t object, uint8_t opCode) = 0;
|
||||
virtual ReturnValue_t addComponent(object_id_t object) { return addComponent(object, 0); };
|
||||
|
|
@ -38,7 +38,7 @@ class PeriodicTaskIF {
|
|||
* Adds an object to the list of objects to be executed.
|
||||
* The objects are executed in the order added.
|
||||
* @param object pointer to the object to add.
|
||||
* @return RETURN_OK on success, returnvalue::FAILED if the object could not be added.
|
||||
* @return returnvalue::OK on success, returnvalue::FAILED if the object could not be added.
|
||||
*/
|
||||
virtual ReturnValue_t addComponent(ExecutableObjectIF* object, uint8_t opCode) = 0;
|
||||
virtual ReturnValue_t addComponent(ExecutableObjectIF* object) { return addComponent(object, 0); }
|
||||
|
|
|
|||
|
|
@ -46,14 +46,14 @@ class SemaphoreIF {
|
|||
* for a maximum of timeoutMs while trying to acquire the semaphore.
|
||||
* This can be used to achieve task synchrnization.
|
||||
* @param timeoutMs
|
||||
* @return - c RETURN_OK for successfull acquisition
|
||||
* @return - c returnvalue::OK for successfull acquisition
|
||||
*/
|
||||
virtual ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
|
||||
uint32_t timeoutMs = 0) = 0;
|
||||
|
||||
/**
|
||||
* Corrensponding call to release a semaphore.
|
||||
* @return -@c RETURN_OK for successfull release
|
||||
* @return -@c returnvalue::OK for successfull release
|
||||
*/
|
||||
virtual ReturnValue_t release() = 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ class CCSDSDistributorIF {
|
|||
* With this call, a class implementing the CCSDSApplicationIF can register
|
||||
* at the distributor.
|
||||
* @param application A pointer to the Application to register.
|
||||
* @return - @c RETURN_OK on success,
|
||||
* @return - @c returnvalue::OK on success,
|
||||
* - @c returnvalue::FAILED on failure.
|
||||
*/
|
||||
virtual ReturnValue_t registerApplication(AcceptsTelecommandsIF* application) = 0;
|
||||
|
|
@ -27,7 +27,7 @@ class CCSDSDistributorIF {
|
|||
* @param apid The APID to register.
|
||||
* @param id The MessageQueueId of the message queue to send the
|
||||
* TC Packets to.
|
||||
* @return - @c RETURN_OK on success,
|
||||
* @return - @c returnvalue::OK on success,
|
||||
* - @c returnvalue::FAILED on failure.
|
||||
*/
|
||||
virtual ReturnValue_t registerApplication(uint16_t apid, MessageQueueId_t id) = 0;
|
||||
|
|
|
|||
|
|
@ -101,10 +101,10 @@ ReturnValue_t CFDPDistributor::registerHandler(AcceptsTelecommandsIF* handler) {
|
|||
MessageQueueId_t CFDPDistributor::getRequestQueue() { return tcQueue->getId(); }
|
||||
|
||||
// ReturnValue_t CFDPDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
|
||||
// if (queueStatus != RETURN_OK) {
|
||||
// if (queueStatus != returnvalue::OK) {
|
||||
// tcStatus = queueStatus;
|
||||
// }
|
||||
// if (tcStatus != RETURN_OK) {
|
||||
// if (tcStatus != returnvalue::OK) {
|
||||
// this->verifyChannel.sendFailureReport(tc_verification::ACCEPTANCE_FAILURE,
|
||||
// currentPacket, tcStatus);
|
||||
// // A failed packet is deleted immediately after reporting,
|
||||
|
|
@ -114,7 +114,7 @@ MessageQueueId_t CFDPDistributor::getRequestQueue() { return tcQueue->getId(); }
|
|||
// } else {
|
||||
// this->verifyChannel.sendSuccessReport(tc_verification::ACCEPTANCE_SUCCESS,
|
||||
// currentPacket);
|
||||
// return RETURN_OK;
|
||||
// return returnvalue::OK;
|
||||
// }
|
||||
// }
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ class CFDPDistributorIF {
|
|||
/**
|
||||
* With this method, Handlers can register themselves at the CFDP Distributor.
|
||||
* @param handler A pointer to the registering Handler.
|
||||
* @return - @c RETURN_OK on success,
|
||||
* @return - @c returnvalue::OK on success,
|
||||
* - @c returnvalue::FAILED on failure.
|
||||
*/
|
||||
virtual ReturnValue_t registerHandler(AcceptsTelecommandsIF* handler) = 0;
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ class PUSDistributorIF {
|
|||
/**
|
||||
* With this method, Services can register themselves at the PUS Distributor.
|
||||
* @param service A pointer to the registering Service.
|
||||
* @return - @c RETURN_OK on success,
|
||||
* @return - @c returnvalue::OK on success,
|
||||
* - @c returnvalue::FAILED on failure.
|
||||
*/
|
||||
virtual ReturnValue_t registerService(AcceptsTelecommandsIF* service) = 0;
|
||||
|
|
|
|||
|
|
@ -101,10 +101,10 @@ class TcDistributor : public SystemObject, public ExecutableObjectIF {
|
|||
* This method gives the child class a chance to perform some kind of
|
||||
* operation after the parent tried to forward the message.
|
||||
* A typically application would be sending success/failure messages.
|
||||
* The default implementation just returns @c RETURN_OK.
|
||||
* The default implementation just returns @c returnvalue::OK.
|
||||
* @param queueStatus The status of the message queue after an attempt
|
||||
* to send the TC.
|
||||
* @return - @c RETURN_OK on success
|
||||
* @return - @c returnvalue::OK on success
|
||||
* - @c returnvalue::FAILED on failure
|
||||
*/
|
||||
virtual ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ class TcPacketCheckIF {
|
|||
* This is the actual method to formally check a certain Packet.
|
||||
* The packet's Application Data can not be checked here.
|
||||
* @param current_packet The packet to check
|
||||
* @return - @c RETURN_OK on success.
|
||||
* @return - @c returnvalue::OK on success.
|
||||
* - @c INCORRECT_CHECKSUM if checksum is invalid.
|
||||
* - @c ILLEGAL_APID if APID does not match.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ class CCSDSTime {
|
|||
* @param to pointer to a CCS struct
|
||||
* @param from pointer to a TimeOfDay Struct
|
||||
* @return
|
||||
* - @c RETURN_OK if OK
|
||||
* - @c returnvalue::OK if OK
|
||||
* - @c INVALID_TIMECODE if not OK
|
||||
*/
|
||||
static ReturnValue_t convertToCcsds(Ccs_seconds *to, Clock::TimeOfDay_t const *from);
|
||||
|
|
@ -115,7 +115,7 @@ class CCSDSTime {
|
|||
* @param to pointer to the CDS struct to generate
|
||||
* @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
|
||||
* @return
|
||||
* - @c RETURN_OK as it assumes a valid timeval.
|
||||
* - @c returnvalue::OK as it assumes a valid timeval.
|
||||
*/
|
||||
static ReturnValue_t convertToCcsds(CDS_short *to, timeval const *from);
|
||||
|
||||
|
|
@ -129,7 +129,7 @@ class CCSDSTime {
|
|||
* @param to pointer to a CCS struct
|
||||
* @param from pointer to a TimeOfDay Struct
|
||||
* @return
|
||||
* - @c RETURN_OK if OK
|
||||
* - @c returnvalue::OK if OK
|
||||
* - @c INVALID_TIMECODE if not OK
|
||||
*/
|
||||
static ReturnValue_t convertToCcsds(Ccs_mseconds *to, Clock::TimeOfDay_t const *from);
|
||||
|
|
@ -145,7 +145,7 @@ class CCSDSTime {
|
|||
* @param from pointer to an CCSDS Time code
|
||||
* @param length length of the Time code
|
||||
* @return
|
||||
* - @c RETURN_OK if successful
|
||||
* - @c returnvalue::OK if successful
|
||||
* - @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
|
||||
* - @c LENGTH_MISMATCH if the length does not match the P Field
|
||||
* - @c INVALID_TIME_FORMAT if the format or a value is invalid
|
||||
|
|
@ -182,7 +182,7 @@ class CCSDSTime {
|
|||
* @param from Buffer to read from
|
||||
* @param foundLength Length found by this function (can be nullptr if unused)
|
||||
* @param maxLength Max length of the buffer to be read
|
||||
* @return ReturnValue_t - RETURN_OK if successful
|
||||
* @return ReturnValue_t - returnvalue::OK if successful
|
||||
* - LENGTH_MISMATCH if expected length is larger than maxLength
|
||||
*/
|
||||
static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from, size_t *foundLength,
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ class Clock {
|
|||
* This system call sets the system time.
|
||||
* To set the time, it uses a TimeOfDay_t struct.
|
||||
* @param time The struct with the time settings to set.
|
||||
* @return -@c RETURN_OK on success. Otherwise, the OS failure code
|
||||
* @return -@c returnvalue::OK on success. Otherwise, the OS failure code
|
||||
* is returned.
|
||||
*/
|
||||
static ReturnValue_t setClock(const TimeOfDay_t *time);
|
||||
|
|
@ -46,7 +46,7 @@ class Clock {
|
|||
* This system call sets the system time.
|
||||
* To set the time, it uses a timeval struct.
|
||||
* @param time The struct with the time settings to set.
|
||||
* @return -@c RETURN_OK on success. Otherwise, the OS failure code is returned.
|
||||
* @return -@c returnvalue::OK on success. Otherwise, the OS failure code is returned.
|
||||
*/
|
||||
static ReturnValue_t setClock(const timeval *time);
|
||||
/**
|
||||
|
|
@ -54,7 +54,7 @@ class Clock {
|
|||
* The timval format has the fields @c tv_sec with seconds and @c tv_usec with
|
||||
* microseconds since an OS-defined epoch.
|
||||
* @param time A pointer to a timeval struct where the current time is stored.
|
||||
* @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
|
||||
* @return @c returnvalue::OK on success. Otherwise, the OS failure code is returned.
|
||||
*/
|
||||
static ReturnValue_t getClock_timeval(timeval *time);
|
||||
|
||||
|
|
@ -62,7 +62,7 @@ class Clock {
|
|||
* Get the time since boot in a timeval struct
|
||||
*
|
||||
* @param[out] time A pointer to a timeval struct where the uptime is stored.
|
||||
* @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
|
||||
* @return @c returnvalue::OK on success. Otherwise, the OS failure code is returned.
|
||||
*
|
||||
* @deprecated, I do not think this should be able to fail, use timeval getUptime()
|
||||
*/
|
||||
|
|
@ -77,7 +77,7 @@ class Clock {
|
|||
* between two calls up to 49 days by always using uint32_t in the calculation
|
||||
*
|
||||
* @param ms uptime in ms
|
||||
* @return RETURN_OK on success. Otherwise, the OS failure code is returned.
|
||||
* @return returnvalue::OK on success. Otherwise, the OS failure code is returned.
|
||||
*/
|
||||
static ReturnValue_t getUptime(uint32_t *uptimeMs);
|
||||
|
||||
|
|
@ -86,7 +86,7 @@ class Clock {
|
|||
* The time is returned in a 64 bit unsigned integer.
|
||||
* @param time A pointer to a 64 bit unisigned integer where the data is stored.
|
||||
* @return
|
||||
* - @c RETURN_OK on success.
|
||||
* - @c returnvalue::OK on success.
|
||||
* - Otherwise, the OS failure code is returned.
|
||||
*/
|
||||
static ReturnValue_t getClock_usecs(uint64_t *time);
|
||||
|
|
@ -94,7 +94,7 @@ class Clock {
|
|||
* Returns the time in a TimeOfDay_t struct.
|
||||
* @param time A pointer to a TimeOfDay_t struct.
|
||||
* @return
|
||||
* - @c RETURN_OK on success.
|
||||
* - @c returnvalue::OK on success.
|
||||
* - Otherwise, the OS failure code is returned.
|
||||
*/
|
||||
static ReturnValue_t getDateAndTime(TimeOfDay_t *time);
|
||||
|
|
@ -111,7 +111,7 @@ class Clock {
|
|||
* @param time The time of day as input
|
||||
* @param timeval The corresponding seconds since the epoch.
|
||||
* @return
|
||||
* - @c RETURN_OK on success.
|
||||
* - @c returnvalue::OK on success.
|
||||
* - Otherwise, the OS failure code is returned.
|
||||
*/
|
||||
static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t *from, timeval *to);
|
||||
|
|
@ -122,7 +122,7 @@ class Clock {
|
|||
*
|
||||
* @param time seconds since unix epoch
|
||||
* @param[out] JD2000 days since J2000
|
||||
* @return @c RETURN_OK
|
||||
* @return @c returnvalue::OK
|
||||
*/
|
||||
static ReturnValue_t convertTimevalToJD2000(timeval time, double *JD2000);
|
||||
|
||||
|
|
@ -136,7 +136,7 @@ class Clock {
|
|||
* @param utc timeval, corresponding to UTC time
|
||||
* @param[out] tt timeval, corresponding to Terrestial Time
|
||||
* @return
|
||||
* - @c RETURN_OK on success
|
||||
* - @c returnvalue::OK on success
|
||||
* - @c returnvalue::FAILED if leapSeconds are not set
|
||||
*/
|
||||
static ReturnValue_t convertUTCToTT(timeval utc, timeval *tt);
|
||||
|
|
@ -146,7 +146,7 @@ class Clock {
|
|||
*
|
||||
* @param leapSeconds_
|
||||
* @return
|
||||
* - @c RETURN_OK on success.
|
||||
* - @c returnvalue::OK on success.
|
||||
*/
|
||||
static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
|
||||
|
||||
|
|
@ -157,7 +157,7 @@ class Clock {
|
|||
*
|
||||
* @param[out] leapSeconds_
|
||||
* @return
|
||||
* - @c RETURN_OK on success.
|
||||
* - @c returnvalue::OK on success.
|
||||
* - @c returnvalue::FAILED on error
|
||||
*/
|
||||
static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
|
||||
|
|
@ -166,7 +166,7 @@ class Clock {
|
|||
/**
|
||||
* Function to check and create the Mutex for the clock
|
||||
* @return
|
||||
* - @c RETURN_OK on success.
|
||||
* - @c returnvalue::OK on success.
|
||||
* - Otherwise @c returnvalue::FAILED if not able to create one
|
||||
*/
|
||||
static ReturnValue_t checkOrCreateClockMutex();
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ class TmStoreFrontendIF {
|
|||
* @param packet Pointer to the newly received Space Packet.
|
||||
* @param address Start address of the packet found
|
||||
* @param isLastPacket Indicates if no more packets can be fetched.
|
||||
* @return If more packets shall be fetched, RETURN_OK must be returned.
|
||||
* @return If more packets shall be fetched, returnvalue::OK must be returned.
|
||||
* Any other code stops fetching packets.
|
||||
*/
|
||||
virtual ReturnValue_t packetRetrieved(TmPacketMinimal* packet, uint32_t address) = 0;
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ class RedirectableDataPointerIF {
|
|||
* large enough
|
||||
* @param args Any additional user arguments required to set the data pointer
|
||||
* @return
|
||||
* - RETURN_OK if the pointer was set successfully
|
||||
* - returnvalue::OK if the pointer was set successfully
|
||||
* - returnvalue::FAILED on general error of if the maximum size is too small
|
||||
*/
|
||||
virtual ReturnValue_t setData(uint8_t* dataPtr, size_t maxSize, void* args = nullptr) = 0;
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ class CFDPPacketStored : public CFDPPacket, public TcPacketStoredBase {
|
|||
* Getter function for the raw data.
|
||||
* @param dataPtr [out] Pointer to the data pointer to set
|
||||
* @param dataSize [out] Address of size to set.
|
||||
* @return -@c RETURN_OK if data was retrieved successfully.
|
||||
* @return -@c returnvalue::OK if data was retrieved successfully.
|
||||
*/
|
||||
ReturnValue_t getData(const uint8_t** dataPtr, size_t* dataSize);
|
||||
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ class TcPacketStoredBase : public TcPacketStoredIF {
|
|||
* Getter function for the raw data.
|
||||
* @param dataPtr [out] Pointer to the data pointer to set
|
||||
* @param dataSize [out] Address of size to set.
|
||||
* @return -@c RETURN_OK if data was retrieved successfully.
|
||||
* @return -@c returnvalue::OK if data was retrieved successfully.
|
||||
*/
|
||||
ReturnValue_t getData(const uint8_t** dataPtr, size_t* dataSize) override;
|
||||
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ class TcPacketStoredIF {
|
|||
* Getter function for the raw data.
|
||||
* @param dataPtr [out] Pointer to the data pointer to set
|
||||
* @param dataSize [out] Address of size to set.
|
||||
* @return -@c RETURN_OK if data was retrieved successfully.
|
||||
* @return -@c returnvalue::OK if data was retrieved successfully.
|
||||
*/
|
||||
virtual ReturnValue_t getData(const uint8_t** dataPtr, size_t* dataSize) = 0;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -184,7 +184,7 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result, Comma
|
|||
|
||||
// In case a new command is to be sent immediately, this is performed here.
|
||||
// If no new command is sent, only analyse reply result by initializing
|
||||
// sendResult as RETURN_OK
|
||||
// sendResult as returnvalue::OK
|
||||
ReturnValue_t sendResult = returnvalue::OK;
|
||||
if (nextCommand->getCommand() != CommandMessage::CMD_NONE) {
|
||||
sendResult = commandQueue->sendMessage(reply->getSender(), nextCommand);
|
||||
|
|
|
|||
|
|
@ -90,7 +90,7 @@ class CommandingServiceBase : public SystemObject,
|
|||
* Handle request queue for external commands.
|
||||
* Handle command Queue for internal commands.
|
||||
* @param opCode is unused here at the moment
|
||||
* @return RETURN_OK
|
||||
* @return returnvalue::OK
|
||||
*/
|
||||
virtual ReturnValue_t performOperation(uint8_t opCode) override;
|
||||
|
||||
|
|
@ -128,7 +128,7 @@ class CommandingServiceBase : public SystemObject,
|
|||
* Check the target subservice
|
||||
* @param subservice[in]
|
||||
* @return
|
||||
* -@c RETURN_OK Subservice valid, continue message handling
|
||||
* -@c returnvalue::OK Subservice valid, continue message handling
|
||||
* -@c INVALID_SUBSERVICE if service is not known, rejects packet.
|
||||
*/
|
||||
virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
|
||||
|
|
@ -143,7 +143,7 @@ class CommandingServiceBase : public SystemObject,
|
|||
* @param id MessageQueue ID is stored here
|
||||
* @param objectId Object ID is extracted and stored here
|
||||
* @return
|
||||
* - @c RETURN_OK Cotinue message handling
|
||||
* - @c returnvalue::OK Cotinue message handling
|
||||
* - @c returnvalue::FAILED Reject the packet and generates a start failure
|
||||
* verification
|
||||
*/
|
||||
|
|
@ -164,7 +164,7 @@ class CommandingServiceBase : public SystemObject,
|
|||
* communication
|
||||
* @param objectId Target object ID
|
||||
* @return
|
||||
* - @c RETURN_OK to generate a verification start message
|
||||
* - @c returnvalue::OK to generate a verification start message
|
||||
* - @c EXECUTION_COMPLETE Fire-and-forget command. Generate a completion
|
||||
* verification message.
|
||||
* - @c Anything else rejects the packets and generates a start failure
|
||||
|
|
@ -189,7 +189,7 @@ class CommandingServiceBase : public SystemObject,
|
|||
* @param objectId Source object ID
|
||||
* @param isStep Flag value to mark steps of command execution
|
||||
* @return
|
||||
* - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
|
||||
* - @c returnvalue::OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
|
||||
* generate TC verification success
|
||||
* - @c INVALID_REPLY Calls handleUnrequestedReply
|
||||
* - Anything else triggers a TC verification failure. If returnvalue::FAILED or
|
||||
|
|
|
|||
|
|
@ -75,14 +75,14 @@ class PusServiceBase : public ExecutableObjectIF,
|
|||
*
|
||||
* @return The returned status_code is directly taken as main error code
|
||||
* in the Verification Report.
|
||||
* On success, RETURN_OK shall be returned.
|
||||
* On success, returnvalue::OK shall be returned.
|
||||
*/
|
||||
virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
|
||||
/**
|
||||
* In performService, implementations can handle periodic,
|
||||
* non-TC-triggered activities.
|
||||
* The performService method is always called.
|
||||
* @return Currently, everything other that RETURN_OK only triggers
|
||||
* @return Currently, everything other that returnvalue::OK only triggers
|
||||
* diagnostic output.
|
||||
*/
|
||||
virtual ReturnValue_t performService() = 0;
|
||||
|
|
@ -92,7 +92,7 @@ class PusServiceBase : public ExecutableObjectIF,
|
|||
* completion verification messages and deletes
|
||||
* the TC requests afterwards.
|
||||
* performService is always executed afterwards.
|
||||
* @return @c RETURN_OK if the periodic performService was successful.
|
||||
* @return @c returnvalue::OK if the periodic performService was successful.
|
||||
* @c returnvalue::FAILED else.
|
||||
*/
|
||||
ReturnValue_t performOperation(uint8_t opCode) override;
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ class SpacePacketParser {
|
|||
* will be set to the detected packet size and startIndex will be set to the start of the
|
||||
* detected packet. buffer and read length will not be incremented but the found length
|
||||
* will be assigned.
|
||||
* -@c RETURN_OK if a packet was found
|
||||
* -@c returnvalue::OK if a packet was found
|
||||
*/
|
||||
ReturnValue_t parseSpacePackets(const uint8_t** buffer, const size_t maxSize, size_t& startIndex,
|
||||
size_t& foundSize, size_t& readLen);
|
||||
|
|
@ -67,7 +67,7 @@ class SpacePacketParser {
|
|||
* -@c SPLIT_PACKET if a packet was found but the detected size exceeds maxSize. foundSize
|
||||
* will be set to the detected packet size and startIndex will be set to the start of the
|
||||
* detected packet
|
||||
* -@c RETURN_OK if a packet was found
|
||||
* -@c returnvalue::OK if a packet was found
|
||||
*/
|
||||
ReturnValue_t parseSpacePackets(const uint8_t* buffer, const size_t maxSize, size_t& startIndex,
|
||||
size_t& foundSize);
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
|
|||
* Set number of packets sent per performOperation().Please note that this
|
||||
* value must be smaller than MAX_STORED_DATA_SENT_PER_CYCLE
|
||||
* @param sentPacketsPerCycle
|
||||
* @return -@c RETURN_OK if value was set successfully
|
||||
* @return -@c returnvalue::OK if value was set successfully
|
||||
* -@c returnvalue::FAILED otherwise, stored value stays the same
|
||||
*/
|
||||
ReturnValue_t setNumberOfSentPacketsPerCycle(uint8_t sentPacketsPerCycle);
|
||||
|
|
@ -39,7 +39,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
|
|||
* Set number of packets sent per performOperation().Please note that this
|
||||
* value must be smaller than MAX_DOWNLINK_PACKETS_STORED
|
||||
* @param sentPacketsPerCycle
|
||||
* @return -@c RETURN_OK if value was set successfully
|
||||
* @return -@c returnvalue::OK if value was set successfully
|
||||
* -@c returnvalue::FAILED otherwise, stored value stays the same
|
||||
*/
|
||||
ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ class GpioIF {
|
|||
* functionality to pull a certain GPIO to high logic level.
|
||||
*
|
||||
* @param gpioId A unique number which specifies the GPIO to drive.
|
||||
* @return Returns RETURN_OK for success. This should never return returnvalue::FAILED.
|
||||
* @return Returns returnvalue::OK for success. This should never return returnvalue::FAILED.
|
||||
*/
|
||||
virtual ReturnValue_t pullHigh(gpioId_t gpioId) = 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ class CommandExecutor {
|
|||
* the result of the system call was not 0. The error value can be accessed using
|
||||
* getLastError
|
||||
* - In non-blocking mode, this call will start
|
||||
* the execution and then return RETURN_OK
|
||||
* the execution and then return returnvalue::OK
|
||||
*/
|
||||
ReturnValue_t execute();
|
||||
/**
|
||||
|
|
@ -77,7 +77,7 @@ class CommandExecutor {
|
|||
* @return
|
||||
* - BYTES_READ if bytes have been read from the executing process. It is recommended to call
|
||||
* check again after this
|
||||
* - RETURN_OK execution is pending, but no bytes have been read from the executing process
|
||||
* - returnvalue::OK execution is pending, but no bytes have been read from the executing process
|
||||
* - returnvalue::FAILED if execution has failed, error value can be accessed using getLastError
|
||||
* - EXECUTION_FINISHED if the process was executed successfully
|
||||
* - NO_COMMAND_LOADED_OR_PENDING self-explanatory
|
||||
|
|
@ -87,7 +87,7 @@ class CommandExecutor {
|
|||
/**
|
||||
* Abort the current command. Should normally not be necessary, check can be used to find
|
||||
* out whether command execution was successful
|
||||
* @return RETURN_OK
|
||||
* @return returnvalue::OK
|
||||
*/
|
||||
ReturnValue_t close();
|
||||
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ class LinuxLibgpioIF : public GpioIF, public SystemObject {
|
|||
*
|
||||
* @param mapToAdd The GPIOs which shall be added to the gpioMap.
|
||||
*
|
||||
* @return RETURN_OK if successful, otherwise returnvalue::FAILED
|
||||
* @return returnvalue::OK if successful, otherwise returnvalue::FAILED
|
||||
*/
|
||||
ReturnValue_t checkForConflicts(GpioMap& mapToAdd);
|
||||
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ class I2cComIF : public DeviceCommunicationIF, public SystemObject {
|
|||
* @param deviceFile The name of the device file. E.g. i2c-0
|
||||
* @param i2cAddress The address of the i2c slave device.
|
||||
* @param fileDescriptor Pointer to device descriptor.
|
||||
* @return RETURN_OK if successful, otherwise returnvalue::FAILED.
|
||||
* @return returnvalue::OK if successful, otherwise returnvalue::FAILED.
|
||||
*/
|
||||
ReturnValue_t openDevice(std::string deviceFile, address_t i2cAddress, int *fileDescriptor);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ class TestAssembly : public AssemblyBase {
|
|||
* @param mode
|
||||
* @param submode
|
||||
* @return
|
||||
* - @c RETURN_OK if ok
|
||||
* - @c returnvalue::OK if ok
|
||||
* - @c NEED_SECOND_STEP if children need to be commanded again
|
||||
*/
|
||||
ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) override;
|
||||
|
|
|
|||
Loading…
Reference in New Issue