Merge branch 'master' into mueller/FixedTimeslotUpdate
This commit is contained in:
commit
d38e13f9d3
@ -1,95 +1,124 @@
|
|||||||
#include "DleEncoder.h"
|
#include "../globalfunctions/DleEncoder.h"
|
||||||
|
|
||||||
DleEncoder::DleEncoder() {
|
DleEncoder::DleEncoder() {}
|
||||||
}
|
|
||||||
|
|
||||||
DleEncoder::~DleEncoder() {
|
DleEncoder::~DleEncoder() {}
|
||||||
|
|
||||||
|
ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
|
||||||
|
size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
|
||||||
|
size_t* encodedLen, bool addStxEtx) {
|
||||||
|
if (maxDestLen < 2) {
|
||||||
|
return STREAM_TOO_SHORT;
|
||||||
|
}
|
||||||
|
size_t encodedIndex = 0, sourceIndex = 0;
|
||||||
|
uint8_t nextByte;
|
||||||
|
if (addStxEtx) {
|
||||||
|
destStream[0] = STX_CHAR;
|
||||||
|
++encodedIndex;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (encodedIndex < maxDestLen and sourceIndex < sourceLen)
|
||||||
|
{
|
||||||
|
nextByte = sourceStream[sourceIndex];
|
||||||
|
// STX, ETX and CR characters in the stream need to be escaped with DLE
|
||||||
|
if (nextByte == STX_CHAR or nextByte == ETX_CHAR or nextByte == CARRIAGE_RETURN) {
|
||||||
|
if (encodedIndex + 1 >= maxDestLen) {
|
||||||
|
return STREAM_TOO_SHORT;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
destStream[encodedIndex] = DLE_CHAR;
|
||||||
|
++encodedIndex;
|
||||||
|
/* Escaped byte will be actual byte + 0x40. This prevents
|
||||||
|
* STX, ETX, and carriage return characters from appearing
|
||||||
|
* in the encoded data stream at all, so when polling an
|
||||||
|
* encoded stream, the transmission can be stopped at ETX.
|
||||||
|
* 0x40 was chosen at random with special requirements:
|
||||||
|
* - Prevent going from one control char to another
|
||||||
|
* - Prevent overflow for common characters */
|
||||||
|
destStream[encodedIndex] = nextByte + 0x40;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// DLE characters are simply escaped with DLE.
|
||||||
|
else if (nextByte == DLE_CHAR) {
|
||||||
|
if (encodedIndex + 1 >= maxDestLen) {
|
||||||
|
return STREAM_TOO_SHORT;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
destStream[encodedIndex] = DLE_CHAR;
|
||||||
|
++encodedIndex;
|
||||||
|
destStream[encodedIndex] = DLE_CHAR;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
destStream[encodedIndex] = nextByte;
|
||||||
|
}
|
||||||
|
++encodedIndex;
|
||||||
|
++sourceIndex;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
|
||||||
|
if (addStxEtx) {
|
||||||
|
destStream[encodedIndex] = ETX_CHAR;
|
||||||
|
++encodedIndex;
|
||||||
|
}
|
||||||
|
*encodedLen = encodedIndex;
|
||||||
|
return RETURN_OK;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
return STREAM_TOO_SHORT;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
|
ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
|
||||||
uint32_t sourceStreamLen, uint32_t *readLen, uint8_t *destStream,
|
size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
|
||||||
uint32_t maxDestStreamlen, uint32_t *decodedLen) {
|
size_t maxDestStreamlen, size_t *decodedLen) {
|
||||||
uint32_t encodedIndex = 0, decodedIndex = 0;
|
size_t encodedIndex = 0, decodedIndex = 0;
|
||||||
uint8_t nextByte;
|
uint8_t nextByte;
|
||||||
if (*sourceStream != STX) {
|
if (*sourceStream != STX_CHAR) {
|
||||||
return RETURN_FAILED;
|
return DECODING_ERROR;
|
||||||
}
|
}
|
||||||
++encodedIndex;
|
++encodedIndex;
|
||||||
|
|
||||||
while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
|
while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
|
||||||
&& (sourceStream[encodedIndex] != ETX)
|
&& (sourceStream[encodedIndex] != ETX_CHAR)
|
||||||
&& (sourceStream[encodedIndex] != STX)) {
|
&& (sourceStream[encodedIndex] != STX_CHAR)) {
|
||||||
if (sourceStream[encodedIndex] == DLE) {
|
if (sourceStream[encodedIndex] == DLE_CHAR) {
|
||||||
nextByte = sourceStream[encodedIndex + 1];
|
nextByte = sourceStream[encodedIndex + 1];
|
||||||
if (nextByte == 0x10) {
|
// The next byte is a DLE character that was escaped by another
|
||||||
|
// DLE character, so we can write it to the destination stream.
|
||||||
|
if (nextByte == DLE_CHAR) {
|
||||||
destStream[decodedIndex] = nextByte;
|
destStream[decodedIndex] = nextByte;
|
||||||
} else {
|
}
|
||||||
if ((nextByte == 0x42) || (nextByte == 0x43)
|
else {
|
||||||
|| (nextByte == 0x4D)) {
|
/* The next byte is a STX, DTX or 0x0D character which
|
||||||
|
* was escaped by a DLE character. The actual byte was
|
||||||
|
* also encoded by adding + 0x40 to prevent having control chars,
|
||||||
|
* in the stream at all, so we convert it back. */
|
||||||
|
if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
|
||||||
destStream[decodedIndex] = nextByte - 0x40;
|
destStream[decodedIndex] = nextByte - 0x40;
|
||||||
} else {
|
}
|
||||||
return RETURN_FAILED;
|
else {
|
||||||
|
return DECODING_ERROR;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
++encodedIndex;
|
++encodedIndex;
|
||||||
} else {
|
}
|
||||||
|
else {
|
||||||
destStream[decodedIndex] = sourceStream[encodedIndex];
|
destStream[decodedIndex] = sourceStream[encodedIndex];
|
||||||
}
|
}
|
||||||
|
|
||||||
++encodedIndex;
|
++encodedIndex;
|
||||||
++decodedIndex;
|
++decodedIndex;
|
||||||
}
|
}
|
||||||
if (sourceStream[encodedIndex] != ETX) {
|
|
||||||
return RETURN_FAILED;
|
if (sourceStream[encodedIndex] != ETX_CHAR) {
|
||||||
} else {
|
*readLen = ++encodedIndex;
|
||||||
|
return DECODING_ERROR;
|
||||||
|
}
|
||||||
|
else {
|
||||||
*readLen = ++encodedIndex;
|
*readLen = ++encodedIndex;
|
||||||
*decodedLen = decodedIndex;
|
*decodedLen = decodedIndex;
|
||||||
return RETURN_OK;
|
return RETURN_OK;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
|
|
||||||
uint32_t sourceLen, uint8_t* destStream, uint32_t maxDestLen,
|
|
||||||
uint32_t* encodedLen, bool addStxEtx) {
|
|
||||||
if (maxDestLen < 2) {
|
|
||||||
return RETURN_FAILED;
|
|
||||||
}
|
|
||||||
uint32_t encodedIndex = 0, sourceIndex = 0;
|
|
||||||
uint8_t nextByte;
|
|
||||||
if (addStxEtx) {
|
|
||||||
destStream[0] = STX;
|
|
||||||
++encodedIndex;
|
|
||||||
}
|
|
||||||
while ((encodedIndex < maxDestLen) && (sourceIndex < sourceLen)) {
|
|
||||||
nextByte = sourceStream[sourceIndex];
|
|
||||||
if ((nextByte == STX) || (nextByte == ETX) || (nextByte == 0x0D)) {
|
|
||||||
if (encodedIndex + 1 >= maxDestLen) {
|
|
||||||
return RETURN_FAILED;
|
|
||||||
} else {
|
|
||||||
destStream[encodedIndex] = DLE;
|
|
||||||
++encodedIndex;
|
|
||||||
destStream[encodedIndex] = nextByte + 0x40;
|
|
||||||
}
|
|
||||||
} else if (nextByte == DLE) {
|
|
||||||
if (encodedIndex + 1 >= maxDestLen) {
|
|
||||||
return RETURN_FAILED;
|
|
||||||
} else {
|
|
||||||
destStream[encodedIndex] = DLE;
|
|
||||||
++encodedIndex;
|
|
||||||
destStream[encodedIndex] = DLE;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
destStream[encodedIndex] = nextByte;
|
|
||||||
}
|
|
||||||
++encodedIndex;
|
|
||||||
++sourceIndex;
|
|
||||||
}
|
|
||||||
if ((sourceIndex == sourceLen) && (encodedIndex < maxDestLen)) {
|
|
||||||
if (addStxEtx) {
|
|
||||||
destStream[encodedIndex] = ETX;
|
|
||||||
++encodedIndex;
|
|
||||||
}
|
|
||||||
*encodedLen = encodedIndex;
|
|
||||||
return RETURN_OK;
|
|
||||||
} else {
|
|
||||||
return RETURN_FAILED;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
@ -1,25 +1,79 @@
|
|||||||
#ifndef DLEENCODER_H_
|
#ifndef FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
|
||||||
#define DLEENCODER_H_
|
#define FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
|
||||||
|
|
||||||
#include "../returnvalues/HasReturnvaluesIF.h"
|
#include "../returnvalues/HasReturnvaluesIF.h"
|
||||||
|
#include <cstddef>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This DLE Encoder (Data Link Encoder) can be used to encode and
|
||||||
|
* decode arbitrary data with ASCII control characters
|
||||||
|
* @details
|
||||||
|
* List of control codes:
|
||||||
|
* https://en.wikipedia.org/wiki/C0_and_C1_control_codes
|
||||||
|
*
|
||||||
|
* This encoder can be used to achieve a basic transport layer when using
|
||||||
|
* char based transmission systems.
|
||||||
|
* The passed source strean is converted into a encoded stream by adding
|
||||||
|
* a STX marker at the start of the stream and an ETX marker at the end of
|
||||||
|
* the stream. Any STX, ETX, DLE and CR occurrences in the source stream are
|
||||||
|
* escaped by a DLE character. The encoder also replaces escaped control chars
|
||||||
|
* by another char, so STX, ETX and CR should not appear anywhere in the actual
|
||||||
|
* encoded data stream.
|
||||||
|
*
|
||||||
|
* When using a strictly char based reception of packets encoded with DLE,
|
||||||
|
* STX can be used to notify a reader that actual data will start to arrive
|
||||||
|
* while ETX can be used to notify the reader that the data has ended.
|
||||||
|
*/
|
||||||
class DleEncoder: public HasReturnvaluesIF {
|
class DleEncoder: public HasReturnvaluesIF {
|
||||||
private:
|
private:
|
||||||
DleEncoder();
|
DleEncoder();
|
||||||
virtual ~DleEncoder();
|
virtual ~DleEncoder();
|
||||||
|
|
||||||
public:
|
public:
|
||||||
static const uint8_t STX = 0x02;
|
static constexpr uint8_t INTERFACE_ID = CLASS_ID::DLE_ENCODER;
|
||||||
static const uint8_t ETX = 0x03;
|
static constexpr ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(0x01);
|
||||||
static const uint8_t DLE = 0x10;
|
static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
|
||||||
|
|
||||||
|
//! Start Of Text character. First character is encoded stream
|
||||||
|
static constexpr uint8_t STX_CHAR = 0x02;
|
||||||
|
//! End Of Text character. Last character in encoded stream
|
||||||
|
static constexpr uint8_t ETX_CHAR = 0x03;
|
||||||
|
//! Data Link Escape character. Used to escape STX, ETX and DLE occurrences
|
||||||
|
//! in the source stream.
|
||||||
|
static constexpr uint8_t DLE_CHAR = 0x10;
|
||||||
|
static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Encodes the give data stream by preceding it with the STX marker
|
||||||
|
* and ending it with an ETX marker. STX, ETX and DLE characters inside
|
||||||
|
* the stream are escaped by DLE characters and also replaced by adding
|
||||||
|
* 0x40 (which is reverted in the decoding process).
|
||||||
|
* @param sourceStream
|
||||||
|
* @param sourceLen
|
||||||
|
* @param destStream
|
||||||
|
* @param maxDestLen
|
||||||
|
* @param encodedLen
|
||||||
|
* @param addStxEtx
|
||||||
|
* Adding STX and ETX can be omitted, if they are added manually.
|
||||||
|
* @return
|
||||||
|
*/
|
||||||
|
static ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen,
|
||||||
|
uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
|
||||||
|
bool addStxEtx = true);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Converts an encoded stream back.
|
||||||
|
* @param sourceStream
|
||||||
|
* @param sourceStreamLen
|
||||||
|
* @param readLen
|
||||||
|
* @param destStream
|
||||||
|
* @param maxDestStreamlen
|
||||||
|
* @param decodedLen
|
||||||
|
* @return
|
||||||
|
*/
|
||||||
static ReturnValue_t decode(const uint8_t *sourceStream,
|
static ReturnValue_t decode(const uint8_t *sourceStream,
|
||||||
uint32_t sourceStreamLen, uint32_t *readLen, uint8_t *destStream,
|
size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
|
||||||
uint32_t maxDestStreamlen, uint32_t *decodedLen);
|
size_t maxDestStreamlen, size_t *decodedLen);
|
||||||
|
|
||||||
static ReturnValue_t encode(const uint8_t *sourceStream, uint32_t sourceLen,
|
|
||||||
uint8_t *destStream, uint32_t maxDestLen, uint32_t *encodedLen,
|
|
||||||
bool addStxEtx = true);
|
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* DLEENCODER_H_ */
|
#endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */
|
||||||
|
34
globalfunctions/PeriodicOperationDivider.cpp
Normal file
34
globalfunctions/PeriodicOperationDivider.cpp
Normal file
@ -0,0 +1,34 @@
|
|||||||
|
#include "PeriodicOperationDivider.h"
|
||||||
|
|
||||||
|
|
||||||
|
PeriodicOperationDivider::PeriodicOperationDivider(uint32_t divider,
|
||||||
|
bool resetAutomatically): resetAutomatically(resetAutomatically),
|
||||||
|
counter(divider), divider(divider) {
|
||||||
|
}
|
||||||
|
|
||||||
|
bool PeriodicOperationDivider::checkAndIncrement() {
|
||||||
|
if(counter >= divider) {
|
||||||
|
if(resetAutomatically) {
|
||||||
|
counter = 0;
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
counter ++;
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
void PeriodicOperationDivider::resetCounter() {
|
||||||
|
counter = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void PeriodicOperationDivider::setDivider(uint32_t newDivider) {
|
||||||
|
divider = newDivider;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t PeriodicOperationDivider::getCounter() const {
|
||||||
|
return counter;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t PeriodicOperationDivider::getDivider() const {
|
||||||
|
return divider;
|
||||||
|
}
|
55
globalfunctions/PeriodicOperationDivider.h
Normal file
55
globalfunctions/PeriodicOperationDivider.h
Normal file
@ -0,0 +1,55 @@
|
|||||||
|
#ifndef FSFW_GLOBALFUNCTIONS_PERIODICOPERATIONDIVIDER_H_
|
||||||
|
#define FSFW_GLOBALFUNCTIONS_PERIODICOPERATIONDIVIDER_H_
|
||||||
|
|
||||||
|
#include <cstdint>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Lightweight helper class to facilitate periodic operation with
|
||||||
|
* decreased frequencies.
|
||||||
|
* @details
|
||||||
|
* This class is useful to perform operations which have to be performed
|
||||||
|
* with a reduced frequency, like debugging printouts in high periodic tasks
|
||||||
|
* or low priority operations.
|
||||||
|
*/
|
||||||
|
class PeriodicOperationDivider {
|
||||||
|
public:
|
||||||
|
/**
|
||||||
|
* Initialize with the desired divider and specify whether the internal
|
||||||
|
* counter will be reset automatically.
|
||||||
|
* @param divider
|
||||||
|
* @param resetAutomatically
|
||||||
|
*/
|
||||||
|
PeriodicOperationDivider(uint32_t divider, bool resetAutomatically = true);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Check whether operation is necessary.
|
||||||
|
* If an operation is necessary and the class has been
|
||||||
|
* configured to be reset automatically, the counter will be reset.
|
||||||
|
* If not, the counter will be incremented.
|
||||||
|
* @return
|
||||||
|
* -@c true if the counter is larger or equal to the divider
|
||||||
|
* -@c false otherwise
|
||||||
|
*/
|
||||||
|
bool checkAndIncrement();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Can be used to reset the counter to 0 manually.
|
||||||
|
*/
|
||||||
|
void resetCounter();
|
||||||
|
uint32_t getCounter() const;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Can be used to set a new divider value.
|
||||||
|
* @param newDivider
|
||||||
|
*/
|
||||||
|
void setDivider(uint32_t newDivider);
|
||||||
|
uint32_t getDivider() const;
|
||||||
|
private:
|
||||||
|
bool resetAutomatically = true;
|
||||||
|
uint32_t counter = 0;
|
||||||
|
uint32_t divider = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#endif /* FSFW_GLOBALFUNCTIONS_PERIODICOPERATIONDIVIDER_H_ */
|
@ -1,9 +1,8 @@
|
|||||||
#include "HealthHelper.h"
|
#include "HealthHelper.h"
|
||||||
#include "../ipc/MessageQueueSenderIF.h"
|
|
||||||
#include "../serviceinterface/ServiceInterfaceStream.h"
|
#include "../serviceinterface/ServiceInterfaceStream.h"
|
||||||
|
|
||||||
HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
|
HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
|
||||||
healthTable(NULL), eventSender(NULL), objectId(objectId), parentQueue(
|
objectId(objectId), owner(owner) {
|
||||||
0), owner(owner) {
|
|
||||||
}
|
}
|
||||||
|
|
||||||
HealthHelper::~HealthHelper() {
|
HealthHelper::~HealthHelper() {
|
||||||
@ -40,9 +39,19 @@ void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
|
|||||||
ReturnValue_t HealthHelper::initialize() {
|
ReturnValue_t HealthHelper::initialize() {
|
||||||
healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
|
healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
|
||||||
eventSender = objectManager->get<EventReportingProxyIF>(objectId);
|
eventSender = objectManager->get<EventReportingProxyIF>(objectId);
|
||||||
if ((healthTable == NULL) || eventSender == NULL) {
|
|
||||||
return HasReturnvaluesIF::RETURN_FAILED;
|
if (healthTable == nullptr) {
|
||||||
|
sif::error << "HealthHelper::initialize: Health table object needs"
|
||||||
|
"to be created in factory." << std::endl;
|
||||||
|
return ObjectManagerIF::CHILD_INIT_FAILED;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if(eventSender == nullptr) {
|
||||||
|
sif::error << "HealthHelper::initialize: Owner has to implement "
|
||||||
|
"ReportingProxyIF." << std::endl;
|
||||||
|
return ObjectManagerIF::CHILD_INIT_FAILED;
|
||||||
|
}
|
||||||
|
|
||||||
ReturnValue_t result = healthTable->registerObject(objectId,
|
ReturnValue_t result = healthTable->registerObject(objectId,
|
||||||
HasHealthIF::HEALTHY);
|
HasHealthIF::HEALTHY);
|
||||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||||
@ -62,22 +71,22 @@ void HealthHelper::setHealth(HasHealthIF::HealthState health) {
|
|||||||
|
|
||||||
void HealthHelper::informParent(HasHealthIF::HealthState health,
|
void HealthHelper::informParent(HasHealthIF::HealthState health,
|
||||||
HasHealthIF::HealthState oldHealth) {
|
HasHealthIF::HealthState oldHealth) {
|
||||||
if (parentQueue == 0) {
|
if (parentQueue == MessageQueueIF::NO_QUEUE) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
CommandMessage message;
|
CommandMessage information;
|
||||||
HealthMessage::setHealthMessage(&message, HealthMessage::HEALTH_INFO,
|
HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
|
||||||
health, oldHealth);
|
health, oldHealth);
|
||||||
if (MessageQueueSenderIF::sendMessage(parentQueue, &message,
|
if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
|
||||||
owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
|
owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
|
||||||
sif::debug << "HealthHelper::informParent: sending health reply failed."
|
sif::debug << "HealthHelper::informParent: sending health reply failed."
|
||||||
<< std::endl;
|
<< std::endl;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void HealthHelper::handleSetHealthCommand(CommandMessage* message) {
|
void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
|
||||||
ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(message));
|
ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
|
||||||
if (message->getSender() == 0) {
|
if (command->getSender() == MessageQueueIF::NO_QUEUE) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
CommandMessage reply;
|
CommandMessage reply;
|
||||||
@ -85,12 +94,12 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* message) {
|
|||||||
HealthMessage::setHealthMessage(&reply,
|
HealthMessage::setHealthMessage(&reply,
|
||||||
HealthMessage::REPLY_HEALTH_SET);
|
HealthMessage::REPLY_HEALTH_SET);
|
||||||
} else {
|
} else {
|
||||||
reply.setReplyRejected(result, message->getCommand());
|
reply.setReplyRejected(result, command->getCommand());
|
||||||
}
|
}
|
||||||
if (MessageQueueSenderIF::sendMessage(message->getSender(), &reply,
|
if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
|
||||||
owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
|
owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
|
||||||
sif::debug
|
sif::debug << "HealthHelper::handleHealthCommand: sending health "
|
||||||
<< "HealthHelper::handleHealthCommand: sending health reply failed."
|
"reply failed." << std::endl;
|
||||||
<< std::endl;
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1,11 +1,13 @@
|
|||||||
#ifndef HEALTHHELPER_H_
|
#ifndef FSFW_HEALTH_HEALTHHELPER_H_
|
||||||
#define HEALTHHELPER_H_
|
#define FSFW_HEALTH_HEALTHHELPER_H_
|
||||||
|
|
||||||
#include "../events/EventManagerIF.h"
|
|
||||||
#include "../events/EventReportingProxyIF.h"
|
|
||||||
#include "HasHealthIF.h"
|
#include "HasHealthIF.h"
|
||||||
#include "HealthMessage.h"
|
#include "HealthMessage.h"
|
||||||
#include "HealthTableIF.h"
|
#include "HealthTableIF.h"
|
||||||
|
|
||||||
|
#include "../events/EventManagerIF.h"
|
||||||
|
#include "../events/EventReportingProxyIF.h"
|
||||||
|
#include "../ipc/MessageQueueIF.h"
|
||||||
#include "../objectmanager/ObjectManagerIF.h"
|
#include "../objectmanager/ObjectManagerIF.h"
|
||||||
#include "../returnvalues/HasReturnvaluesIF.h"
|
#include "../returnvalues/HasReturnvaluesIF.h"
|
||||||
|
|
||||||
@ -27,8 +29,8 @@ public:
|
|||||||
/**
|
/**
|
||||||
* ctor
|
* ctor
|
||||||
*
|
*
|
||||||
|
* @param owner
|
||||||
* @param objectId the object Id to use when communication with the HealthTable
|
* @param objectId the object Id to use when communication with the HealthTable
|
||||||
* @param useAsFrom id to use as from id when sending replies, can be set to 0
|
|
||||||
*/
|
*/
|
||||||
HealthHelper(HasHealthIF* owner, object_id_t objectId);
|
HealthHelper(HasHealthIF* owner, object_id_t objectId);
|
||||||
|
|
||||||
@ -39,12 +41,12 @@ public:
|
|||||||
*
|
*
|
||||||
* only valid after initialize() has been called
|
* only valid after initialize() has been called
|
||||||
*/
|
*/
|
||||||
HealthTableIF *healthTable;
|
HealthTableIF *healthTable = nullptr;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Proxy to forward events.
|
* Proxy to forward events.
|
||||||
*/
|
*/
|
||||||
EventReportingProxyIF* eventSender;
|
EventReportingProxyIF* eventSender = nullptr;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Try to handle the message.
|
* Try to handle the message.
|
||||||
@ -100,7 +102,7 @@ private:
|
|||||||
/**
|
/**
|
||||||
* The Queue of the parent
|
* The Queue of the parent
|
||||||
*/
|
*/
|
||||||
MessageQueueId_t parentQueue;
|
MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* The one using the healthHelper.
|
* The one using the healthHelper.
|
||||||
@ -117,4 +119,4 @@ private:
|
|||||||
void handleSetHealthCommand(CommandMessage *message);
|
void handleSetHealthCommand(CommandMessage *message);
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* HEALTHHELPER_H_ */
|
#endif /* FSFW_HEALTH_HEALTHHELPER_H_ */
|
||||||
|
@ -64,6 +64,11 @@ ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
|
|||||||
void PeriodicTask::taskFunctionality() {
|
void PeriodicTask::taskFunctionality() {
|
||||||
TickType_t xLastWakeTime;
|
TickType_t xLastWakeTime;
|
||||||
const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
|
const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
|
||||||
|
|
||||||
|
for (auto const &object: objectList) {
|
||||||
|
object->initializeAfterTaskCreation();
|
||||||
|
}
|
||||||
|
|
||||||
/* The xLastWakeTime variable needs to be initialized with the current tick
|
/* The xLastWakeTime variable needs to be initialized with the current tick
|
||||||
count. Note that this is the only time the variable is written to
|
count. Note that this is the only time the variable is written to
|
||||||
explicitly. After this assignment, xLastWakeTime is updated automatically
|
explicitly. After this assignment, xLastWakeTime is updated automatically
|
||||||
|
@ -1,11 +1,10 @@
|
|||||||
#ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
|
#ifndef FSFW_OSAL_FREERTOS_PERIODICTASK_H_
|
||||||
#define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
|
#define FSFW_OSAL_FREERTOS_PERIODICTASK_H_
|
||||||
|
|
||||||
|
#include "FreeRTOSTaskIF.h"
|
||||||
#include "../../objectmanager/ObjectManagerIF.h"
|
#include "../../objectmanager/ObjectManagerIF.h"
|
||||||
#include "../../tasks/PeriodicTaskIF.h"
|
#include "../../tasks/PeriodicTaskIF.h"
|
||||||
#include "../../tasks/Typedef.h"
|
#include "../../tasks/Typedef.h"
|
||||||
#include "FreeRTOSTaskIF.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <freertos/FreeRTOS.h>
|
#include <freertos/FreeRTOS.h>
|
||||||
#include <freertos/task.h>
|
#include <freertos/task.h>
|
||||||
@ -24,7 +23,6 @@ public:
|
|||||||
/**
|
/**
|
||||||
* Keep in Mind that you need to call before this vTaskStartScheduler()!
|
* Keep in Mind that you need to call before this vTaskStartScheduler()!
|
||||||
* A lot of task parameters are set in "FreeRTOSConfig.h".
|
* A lot of task parameters are set in "FreeRTOSConfig.h".
|
||||||
* TODO: why does this need to be called before vTaskStartScheduler?
|
|
||||||
* @details
|
* @details
|
||||||
* The class is initialized without allocated objects.
|
* The class is initialized without allocated objects.
|
||||||
* These need to be added with #addComponent.
|
* These need to be added with #addComponent.
|
||||||
@ -125,4 +123,4 @@ protected:
|
|||||||
void handleMissedDeadline();
|
void handleMissedDeadline();
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* PERIODICTASK_H_ */
|
#endif /* FSFW_OSAL_FREERTOS_PERIODICTASK_H_ */
|
||||||
|
227
osal/host/Clock.cpp
Normal file
227
osal/host/Clock.cpp
Normal file
@ -0,0 +1,227 @@
|
|||||||
|
#include "../../serviceinterface/ServiceInterfaceStream.h"
|
||||||
|
#include "../../timemanager/Clock.h"
|
||||||
|
|
||||||
|
#include <chrono>
|
||||||
|
#if defined(WIN32)
|
||||||
|
#include <windows.h>
|
||||||
|
#elif defined(LINUX)
|
||||||
|
#include <fstream>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
uint16_t Clock::leapSeconds = 0;
|
||||||
|
MutexIF* Clock::timeMutex = NULL;
|
||||||
|
|
||||||
|
using SystemClock = std::chrono::system_clock;
|
||||||
|
|
||||||
|
uint32_t Clock::getTicksPerSecond(void){
|
||||||
|
sif::warning << "Clock::getTicksPerSecond: not implemented yet" << std::endl;
|
||||||
|
return 0;
|
||||||
|
//return CLOCKS_PER_SEC;
|
||||||
|
//uint32_t ticks = sysconf(_SC_CLK_TCK);
|
||||||
|
//return ticks;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
|
||||||
|
// do some magic with chrono
|
||||||
|
sif::warning << "Clock::setClock: not implemented yet" << std::endl;
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Clock::setClock(const timeval* time) {
|
||||||
|
// do some magic with chrono
|
||||||
|
#if defined(WIN32)
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
#elif defined(LINUX)
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
#else
|
||||||
|
|
||||||
|
#endif
|
||||||
|
sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Clock::getClock_timeval(timeval* time) {
|
||||||
|
#if defined(WIN32)
|
||||||
|
auto now = std::chrono::system_clock::now();
|
||||||
|
auto secondsChrono = std::chrono::time_point_cast<std::chrono::seconds>(now);
|
||||||
|
auto epoch = now.time_since_epoch();
|
||||||
|
time->tv_sec = std::chrono::duration_cast<std::chrono::seconds>(epoch).count();
|
||||||
|
auto fraction = now - secondsChrono;
|
||||||
|
time->tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
|
||||||
|
fraction).count();
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
#elif defined(LINUX)
|
||||||
|
timespec timeUnix;
|
||||||
|
int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
|
||||||
|
if(status!=0){
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
time->tv_sec = timeUnix.tv_sec;
|
||||||
|
time->tv_usec = timeUnix.tv_nsec / 1000.0;
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
#else
|
||||||
|
sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
|
||||||
|
// do some magic with chrono
|
||||||
|
sif::warning << "Clock::gerClock_usecs: not implemented yet" << std::endl;
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
timeval Clock::getUptime() {
|
||||||
|
timeval timeval;
|
||||||
|
#if defined(WIN32)
|
||||||
|
auto uptime = std::chrono::milliseconds(GetTickCount64());
|
||||||
|
auto secondsChrono = std::chrono::duration_cast<std::chrono::seconds>(uptime);
|
||||||
|
timeval.tv_sec = secondsChrono.count();
|
||||||
|
auto fraction = uptime - secondsChrono;
|
||||||
|
timeval.tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
|
||||||
|
fraction).count();
|
||||||
|
#elif defined(LINUX)
|
||||||
|
double uptimeSeconds;
|
||||||
|
if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds)
|
||||||
|
{
|
||||||
|
// value is rounded down automatically
|
||||||
|
timeval.tv_sec = uptimeSeconds;
|
||||||
|
timeval.tv_usec = uptimeSeconds *(double) 1e6 - (timeval.tv_sec *1e6);
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
|
||||||
|
#endif
|
||||||
|
return timeval;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Clock::getUptime(timeval* uptime) {
|
||||||
|
*uptime = getUptime();
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
|
||||||
|
timeval uptime = getUptime();
|
||||||
|
*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
|
||||||
|
// do some magic with chrono (C++20!)
|
||||||
|
// Right now, the library doesn't have the new features yet.
|
||||||
|
// so we work around that for now.
|
||||||
|
auto now = SystemClock::now();
|
||||||
|
auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(now);
|
||||||
|
auto fraction = now - seconds;
|
||||||
|
time_t tt = SystemClock::to_time_t(now);
|
||||||
|
struct tm* timeInfo;
|
||||||
|
timeInfo = gmtime(&tt);
|
||||||
|
time->year = timeInfo->tm_year + 1900;
|
||||||
|
time->month = timeInfo->tm_mon+1;
|
||||||
|
time->day = timeInfo->tm_mday;
|
||||||
|
time->hour = timeInfo->tm_hour;
|
||||||
|
time->minute = timeInfo->tm_min;
|
||||||
|
time->second = timeInfo->tm_sec;
|
||||||
|
auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
|
||||||
|
time->usecond = usecond.count();
|
||||||
|
|
||||||
|
//sif::warning << "Clock::getDateAndTime: not implemented yet" << std::endl;
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
|
||||||
|
timeval* to) {
|
||||||
|
struct tm time_tm;
|
||||||
|
|
||||||
|
time_tm.tm_year = from->year - 1900;
|
||||||
|
time_tm.tm_mon = from->month - 1;
|
||||||
|
time_tm.tm_mday = from->day;
|
||||||
|
|
||||||
|
time_tm.tm_hour = from->hour;
|
||||||
|
time_tm.tm_min = from->minute;
|
||||||
|
time_tm.tm_sec = from->second;
|
||||||
|
|
||||||
|
time_t seconds = mktime(&time_tm);
|
||||||
|
|
||||||
|
to->tv_sec = seconds;
|
||||||
|
to->tv_usec = from->usecond;
|
||||||
|
//Fails in 2038..
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
sif::warning << "Clock::convertTimeBla: not implemented yet" << std::endl;
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
|
||||||
|
*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
|
||||||
|
/ 3600.;
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
|
||||||
|
//SHOULDDO: works not for dates in the past (might have less leap seconds)
|
||||||
|
if (timeMutex == NULL) {
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint16_t leapSeconds;
|
||||||
|
ReturnValue_t result = getLeapSeconds(&leapSeconds);
|
||||||
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
timeval leapSeconds_timeval = { 0, 0 };
|
||||||
|
leapSeconds_timeval.tv_sec = leapSeconds;
|
||||||
|
|
||||||
|
//initial offset between UTC and TAI
|
||||||
|
timeval UTCtoTAI1972 = { 10, 0 };
|
||||||
|
|
||||||
|
timeval TAItoTT = { 32, 184000 };
|
||||||
|
|
||||||
|
*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
|
||||||
|
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
|
||||||
|
if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
|
||||||
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
leapSeconds = leapSeconds_;
|
||||||
|
|
||||||
|
result = timeMutex->unlockMutex();
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
|
||||||
|
if(timeMutex == nullptr){
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
|
||||||
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
*leapSeconds_ = leapSeconds;
|
||||||
|
|
||||||
|
result = timeMutex->unlockMutex();
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Clock::checkOrCreateClockMutex(){
|
||||||
|
if(timeMutex == nullptr){
|
||||||
|
MutexFactory* mutexFactory = MutexFactory::instance();
|
||||||
|
if (mutexFactory == nullptr) {
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
timeMutex = mutexFactory->createMutex();
|
||||||
|
if (timeMutex == nullptr) {
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
197
osal/host/FixedTimeslotTask.cpp
Normal file
197
osal/host/FixedTimeslotTask.cpp
Normal file
@ -0,0 +1,197 @@
|
|||||||
|
#include "../../osal/host/FixedTimeslotTask.h"
|
||||||
|
|
||||||
|
#include "../../ipc/MutexFactory.h"
|
||||||
|
#include "../../osal/host/Mutex.h"
|
||||||
|
#include "../../osal/host/FixedTimeslotTask.h"
|
||||||
|
|
||||||
|
#include "../../serviceinterface/ServiceInterfaceStream.h"
|
||||||
|
#include "../../tasks/ExecutableObjectIF.h"
|
||||||
|
|
||||||
|
#include <thread>
|
||||||
|
#include <chrono>
|
||||||
|
|
||||||
|
#if defined(WIN32)
|
||||||
|
#include <windows.h>
|
||||||
|
#elif defined(LINUX)
|
||||||
|
#include <pthread.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
|
||||||
|
TaskStackSize setStack, TaskPeriod setPeriod,
|
||||||
|
void (*setDeadlineMissedFunc)()) :
|
||||||
|
started(false), pollingSeqTable(setPeriod*1000), taskName(name),
|
||||||
|
period(setPeriod), deadlineMissedFunc(setDeadlineMissedFunc) {
|
||||||
|
// It is propably possible to set task priorities by using the native
|
||||||
|
// task handles for Windows / Linux
|
||||||
|
mainThread = std::thread(&FixedTimeslotTask::taskEntryPoint, this, this);
|
||||||
|
#if defined(WIN32)
|
||||||
|
/* List of possible priority classes:
|
||||||
|
* https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
|
||||||
|
* nf-processthreadsapi-setpriorityclass
|
||||||
|
* And respective thread priority numbers:
|
||||||
|
* https://docs.microsoft.com/en-us/windows/
|
||||||
|
* win32/procthread/scheduling-priorities */
|
||||||
|
int result = SetPriorityClass(
|
||||||
|
reinterpret_cast<HANDLE>(mainThread.native_handle()),
|
||||||
|
ABOVE_NORMAL_PRIORITY_CLASS);
|
||||||
|
if(result != 0) {
|
||||||
|
sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
|
||||||
|
<< GetLastError() << std::endl;
|
||||||
|
}
|
||||||
|
result = SetThreadPriority(
|
||||||
|
reinterpret_cast<HANDLE>(mainThread.native_handle()),
|
||||||
|
THREAD_PRIORITY_NORMAL);
|
||||||
|
if(result != 0) {
|
||||||
|
sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
|
||||||
|
<< GetLastError() << std::endl;
|
||||||
|
}
|
||||||
|
#elif defined(LINUX)
|
||||||
|
// we can just copy and paste the code from linux here.
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
FixedTimeslotTask::~FixedTimeslotTask(void) {
|
||||||
|
//Do not delete objects, we were responsible for ptrs only.
|
||||||
|
terminateThread = true;
|
||||||
|
if(mainThread.joinable()) {
|
||||||
|
mainThread.join();
|
||||||
|
}
|
||||||
|
delete this;
|
||||||
|
}
|
||||||
|
|
||||||
|
void FixedTimeslotTask::taskEntryPoint(void* argument) {
|
||||||
|
FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
|
||||||
|
|
||||||
|
if (not originalTask->started) {
|
||||||
|
// we have to suspend/block here until the task is started.
|
||||||
|
// if semaphores are implemented, use them here.
|
||||||
|
std::unique_lock<std::mutex> lock(initMutex);
|
||||||
|
initCondition.wait(lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
this->taskFunctionality();
|
||||||
|
sif::debug << "FixedTimeslotTask::taskEntryPoint: "
|
||||||
|
"Returned from taskFunctionality." << std::endl;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t FixedTimeslotTask::startTask() {
|
||||||
|
started = true;
|
||||||
|
|
||||||
|
// Notify task to start.
|
||||||
|
std::lock_guard<std::mutex> lock(initMutex);
|
||||||
|
initCondition.notify_one();
|
||||||
|
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
|
||||||
|
std::this_thread::sleep_for(std::chrono::milliseconds(ms));
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
void FixedTimeslotTask::taskFunctionality() {
|
||||||
|
pollingSeqTable.intializeSequenceAfterTaskCreation();
|
||||||
|
|
||||||
|
// A local iterator for the Polling Sequence Table is created to
|
||||||
|
// find the start time for the first entry.
|
||||||
|
auto slotListIter = pollingSeqTable.current;
|
||||||
|
|
||||||
|
// Get start time for first entry.
|
||||||
|
chron_ms interval(slotListIter->pollingTimeMs);
|
||||||
|
auto currentStartTime {
|
||||||
|
std::chrono::duration_cast<chron_ms>(
|
||||||
|
std::chrono::system_clock::now().time_since_epoch())
|
||||||
|
};
|
||||||
|
if(interval.count() > 0) {
|
||||||
|
delayForInterval(¤tStartTime, interval);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Enter the loop that defines the task behavior. */
|
||||||
|
for (;;) {
|
||||||
|
if(terminateThread.load()) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
//The component for this slot is executed and the next one is chosen.
|
||||||
|
this->pollingSeqTable.executeAndAdvance();
|
||||||
|
if (not pollingSeqTable.slotFollowsImmediately()) {
|
||||||
|
// we need to wait before executing the current slot
|
||||||
|
//this gives us the time to wait:
|
||||||
|
interval = chron_ms(this->pollingSeqTable.getIntervalToPreviousSlotMs());
|
||||||
|
delayForInterval(¤tStartTime, interval);
|
||||||
|
//TODO deadline missed check
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
|
||||||
|
uint32_t slotTimeMs, int8_t executionStep) {
|
||||||
|
ExecutableObjectIF* executableObject = objectManager->
|
||||||
|
get<ExecutableObjectIF>(componentId);
|
||||||
|
if (executableObject != nullptr) {
|
||||||
|
pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep,
|
||||||
|
executableObject, this);
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
sif::error << "Component " << std::hex << componentId <<
|
||||||
|
" not found, not adding it to pst" << std::endl;
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t FixedTimeslotTask::checkSequence() const {
|
||||||
|
return pollingSeqTable.checkSequence();
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t FixedTimeslotTask::getPeriodMs() const {
|
||||||
|
return period * 1000;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool FixedTimeslotTask::delayForInterval(chron_ms * previousWakeTimeMs,
|
||||||
|
const chron_ms interval) {
|
||||||
|
bool shouldDelay = false;
|
||||||
|
//Get current wakeup time
|
||||||
|
auto currentStartTime =
|
||||||
|
std::chrono::duration_cast<chron_ms>(
|
||||||
|
std::chrono::system_clock::now().time_since_epoch());
|
||||||
|
/* Generate the tick time at which the task wants to wake. */
|
||||||
|
auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
|
||||||
|
|
||||||
|
if (currentStartTime < *previousWakeTimeMs) {
|
||||||
|
/* The tick count has overflowed since this function was
|
||||||
|
lasted called. In this case the only time we should ever
|
||||||
|
actually delay is if the wake time has also overflowed,
|
||||||
|
and the wake time is greater than the tick time. When this
|
||||||
|
is the case it is as if neither time had overflowed. */
|
||||||
|
if ((nextTimeToWake_ms < *previousWakeTimeMs)
|
||||||
|
&& (nextTimeToWake_ms > currentStartTime)) {
|
||||||
|
shouldDelay = true;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
/* The tick time has not overflowed. In this case we will
|
||||||
|
delay if either the wake time has overflowed, and/or the
|
||||||
|
tick time is less than the wake time. */
|
||||||
|
if ((nextTimeToWake_ms < *previousWakeTimeMs)
|
||||||
|
|| (nextTimeToWake_ms > currentStartTime)) {
|
||||||
|
shouldDelay = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Update the wake time ready for the next call. */
|
||||||
|
|
||||||
|
(*previousWakeTimeMs) = nextTimeToWake_ms;
|
||||||
|
|
||||||
|
if (shouldDelay) {
|
||||||
|
auto sleepTime = std::chrono::duration_cast<chron_ms>(
|
||||||
|
nextTimeToWake_ms - currentStartTime);
|
||||||
|
std::this_thread::sleep_for(sleepTime);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
//We are shifting the time in case the deadline was missed like rtems
|
||||||
|
(*previousWakeTimeMs) = currentStartTime;
|
||||||
|
return false;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
130
osal/host/FixedTimeslotTask.h
Normal file
130
osal/host/FixedTimeslotTask.h
Normal file
@ -0,0 +1,130 @@
|
|||||||
|
#ifndef FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
|
||||||
|
#define FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
|
||||||
|
|
||||||
|
#include "../../objectmanager/ObjectManagerIF.h"
|
||||||
|
#include "../../tasks/FixedSlotSequence.h"
|
||||||
|
#include "../../tasks/FixedTimeslotTaskIF.h"
|
||||||
|
#include "../../tasks/Typedef.h"
|
||||||
|
|
||||||
|
#include <vector>
|
||||||
|
#include <thread>
|
||||||
|
#include <condition_variable>
|
||||||
|
#include <atomic>
|
||||||
|
|
||||||
|
class ExecutableObjectIF;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This class represents a task for periodic activities with multiple
|
||||||
|
* steps and strict timeslot requirements for these steps.
|
||||||
|
* @details
|
||||||
|
* @ingroup task_handling
|
||||||
|
*/
|
||||||
|
class FixedTimeslotTask: public FixedTimeslotTaskIF {
|
||||||
|
public:
|
||||||
|
/**
|
||||||
|
* @brief Standard constructor of the class.
|
||||||
|
* @details
|
||||||
|
* The class is initialized without allocated objects. These need to be
|
||||||
|
* added with #addComponent.
|
||||||
|
* @param priority
|
||||||
|
* @param stack_size
|
||||||
|
* @param setPeriod
|
||||||
|
* @param setDeadlineMissedFunc
|
||||||
|
* The function pointer to the deadline missed function that shall be
|
||||||
|
* assigned.
|
||||||
|
*/
|
||||||
|
FixedTimeslotTask(const char *name, TaskPriority setPriority,
|
||||||
|
TaskStackSize setStack, TaskPeriod setPeriod,
|
||||||
|
void (*setDeadlineMissedFunc)());
|
||||||
|
/**
|
||||||
|
* @brief Currently, the executed object's lifetime is not coupled with
|
||||||
|
* the task object's lifetime, so the destructor is empty.
|
||||||
|
*/
|
||||||
|
virtual ~FixedTimeslotTask(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief The method to start the task.
|
||||||
|
* @details The method starts the task with the respective system call.
|
||||||
|
* Entry point is the taskEntryPoint method described below.
|
||||||
|
* The address of the task object is passed as an argument
|
||||||
|
* to the system call.
|
||||||
|
*/
|
||||||
|
ReturnValue_t startTask(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Add timeslot to the polling sequence table.
|
||||||
|
* @param componentId
|
||||||
|
* @param slotTimeMs
|
||||||
|
* @param executionStep
|
||||||
|
* @return
|
||||||
|
*/
|
||||||
|
ReturnValue_t addSlot(object_id_t componentId,
|
||||||
|
uint32_t slotTimeMs, int8_t executionStep);
|
||||||
|
|
||||||
|
ReturnValue_t checkSequence() const override;
|
||||||
|
|
||||||
|
uint32_t getPeriodMs() const;
|
||||||
|
|
||||||
|
ReturnValue_t sleepFor(uint32_t ms);
|
||||||
|
|
||||||
|
protected:
|
||||||
|
using chron_ms = std::chrono::milliseconds;
|
||||||
|
|
||||||
|
bool started;
|
||||||
|
//!< Typedef for the List of objects.
|
||||||
|
typedef std::vector<ExecutableObjectIF*> ObjectList;
|
||||||
|
std::thread mainThread;
|
||||||
|
std::atomic<bool> terminateThread = false;
|
||||||
|
|
||||||
|
//! Polling sequence table which contains the object to execute
|
||||||
|
//! and information like the timeslots and the passed execution step.
|
||||||
|
FixedSlotSequence pollingSeqTable;
|
||||||
|
|
||||||
|
std::condition_variable initCondition;
|
||||||
|
std::mutex initMutex;
|
||||||
|
std::string taskName;
|
||||||
|
/**
|
||||||
|
* @brief The period of the task.
|
||||||
|
* @details
|
||||||
|
* The period determines the frequency of the task's execution.
|
||||||
|
* It is expressed in clock ticks.
|
||||||
|
*/
|
||||||
|
TaskPeriod period;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief The pointer to the deadline-missed function.
|
||||||
|
* @details
|
||||||
|
* This pointer stores the function that is executed if the task's deadline
|
||||||
|
* is missed. So, each may react individually on a timing failure.
|
||||||
|
* The pointer may be NULL, then nothing happens on missing the deadline.
|
||||||
|
* The deadline is equal to the next execution of the periodic task.
|
||||||
|
*/
|
||||||
|
void (*deadlineMissedFunc)(void);
|
||||||
|
/**
|
||||||
|
* @brief This is the function executed in the new task's context.
|
||||||
|
* @details
|
||||||
|
* It converts the argument back to the thread object type and copies the
|
||||||
|
* class instance to the task context.
|
||||||
|
* The taskFunctionality method is called afterwards.
|
||||||
|
* @param A pointer to the task object itself is passed as argument.
|
||||||
|
*/
|
||||||
|
|
||||||
|
void taskEntryPoint(void* argument);
|
||||||
|
/**
|
||||||
|
* @brief The function containing the actual functionality of the task.
|
||||||
|
* @details
|
||||||
|
* The method sets and starts the task's period, then enters a loop that is
|
||||||
|
* repeated as long as the isRunning attribute is true. Within the loop,
|
||||||
|
* all performOperation methods of the added objects are called. Afterwards
|
||||||
|
* the checkAndRestartPeriod system call blocks the task until the next
|
||||||
|
* period. On missing the deadline, the deadlineMissedFunction is executed.
|
||||||
|
*/
|
||||||
|
void taskFunctionality(void);
|
||||||
|
|
||||||
|
bool delayForInterval(chron_ms * previousWakeTimeMs,
|
||||||
|
const chron_ms interval);
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#endif /* FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_ */
|
159
osal/host/MessageQueue.cpp
Normal file
159
osal/host/MessageQueue.cpp
Normal file
@ -0,0 +1,159 @@
|
|||||||
|
#include "MessageQueue.h"
|
||||||
|
#include "QueueMapManager.h"
|
||||||
|
|
||||||
|
#include "../../serviceinterface/ServiceInterfaceStream.h"
|
||||||
|
#include "../../ipc/MutexFactory.h"
|
||||||
|
#include "../../ipc/MutexHelper.h"
|
||||||
|
|
||||||
|
MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
|
||||||
|
messageSize(maxMessageSize), messageDepth(messageDepth) {
|
||||||
|
queueLock = MutexFactory::instance()->createMutex();
|
||||||
|
auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
|
||||||
|
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||||
|
sif::error << "MessageQueue::MessageQueue:"
|
||||||
|
<< " Could not be created" << std::endl;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
MessageQueue::~MessageQueue() {
|
||||||
|
MutexFactory::instance()->deleteMutex(queueLock);
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
|
||||||
|
MessageQueueMessageIF* message, bool ignoreFault) {
|
||||||
|
return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
|
||||||
|
return sendToDefaultFrom(message, this->getId());
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
|
||||||
|
MessageQueueId_t sentFrom, bool ignoreFault) {
|
||||||
|
return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
|
||||||
|
if (this->lastPartner != 0) {
|
||||||
|
return sendMessageFrom(this->lastPartner, message, this->getId());
|
||||||
|
} else {
|
||||||
|
return MessageQueueIF::NO_REPLY_PARTNER;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
|
||||||
|
MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
|
||||||
|
bool ignoreFault) {
|
||||||
|
return sendMessageFromMessageQueue(sendTo, message, sentFrom,
|
||||||
|
ignoreFault);
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
|
||||||
|
MessageQueueId_t* receivedFrom) {
|
||||||
|
ReturnValue_t status = this->receiveMessage(message);
|
||||||
|
if(status == HasReturnvaluesIF::RETURN_OK) {
|
||||||
|
*receivedFrom = this->lastPartner;
|
||||||
|
}
|
||||||
|
return status;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
|
||||||
|
if(messageQueue.empty()) {
|
||||||
|
return MessageQueueIF::EMPTY;
|
||||||
|
}
|
||||||
|
// not sure this will work..
|
||||||
|
//*message = std::move(messageQueue.front());
|
||||||
|
MutexHelper mutexLock(queueLock, MutexIF::TimeoutType::WAITING, 20);
|
||||||
|
MessageQueueMessage* currentMessage = &messageQueue.front();
|
||||||
|
std::copy(currentMessage->getBuffer(),
|
||||||
|
currentMessage->getBuffer() + messageSize, message->getBuffer());
|
||||||
|
messageQueue.pop();
|
||||||
|
// The last partner is the first uint32_t field in the message
|
||||||
|
this->lastPartner = message->getSender();
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
MessageQueueId_t MessageQueue::getLastPartner() const {
|
||||||
|
return lastPartner;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t MessageQueue::flush(uint32_t* count) {
|
||||||
|
*count = messageQueue.size();
|
||||||
|
// Clears the queue.
|
||||||
|
messageQueue = std::queue<MessageQueueMessage>();
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
MessageQueueId_t MessageQueue::getId() const {
|
||||||
|
return mqId;
|
||||||
|
}
|
||||||
|
|
||||||
|
void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
|
||||||
|
defaultDestinationSet = true;
|
||||||
|
this->defaultDestination = defaultDestination;
|
||||||
|
}
|
||||||
|
|
||||||
|
MessageQueueId_t MessageQueue::getDefaultDestination() const {
|
||||||
|
return defaultDestination;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool MessageQueue::isDefaultDestinationSet() const {
|
||||||
|
return defaultDestinationSet;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// static core function to send messages.
|
||||||
|
ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
|
||||||
|
MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
|
||||||
|
bool ignoreFault) {
|
||||||
|
if(message->getMessageSize() > message->getMaximumMessageSize()) {
|
||||||
|
// Actually, this should never happen or an error will be emitted
|
||||||
|
// in MessageQueueMessage.
|
||||||
|
// But I will still return a failure here.
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
MessageQueue* targetQueue = dynamic_cast<MessageQueue*>(
|
||||||
|
QueueMapManager::instance()->getMessageQueue(sendTo));
|
||||||
|
if(targetQueue == nullptr) {
|
||||||
|
if(not ignoreFault) {
|
||||||
|
InternalErrorReporterIF* internalErrorReporter =
|
||||||
|
objectManager->get<InternalErrorReporterIF>(
|
||||||
|
objects::INTERNAL_ERROR_REPORTER);
|
||||||
|
if (internalErrorReporter != nullptr) {
|
||||||
|
internalErrorReporter->queueMessageNotSent();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// TODO: Better returnvalue
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
|
||||||
|
if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
|
||||||
|
MutexHelper mutexLock(targetQueue->queueLock,
|
||||||
|
MutexIF::TimeoutType::WAITING, 20);
|
||||||
|
// not ideal, works for now though.
|
||||||
|
MessageQueueMessage* mqmMessage =
|
||||||
|
dynamic_cast<MessageQueueMessage*>(message);
|
||||||
|
if(message != nullptr) {
|
||||||
|
targetQueue->messageQueue.push(*mqmMessage);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
sif::error << "MessageQueue::sendMessageFromMessageQueue: Message"
|
||||||
|
"is not MessageQueueMessage!" << std::endl;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
return MessageQueueIF::FULL;
|
||||||
|
}
|
||||||
|
message->setSender(sentFrom);
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t MessageQueue::lockQueue(MutexIF::TimeoutType timeoutType,
|
||||||
|
dur_millis_t lockTimeout) {
|
||||||
|
return queueLock->lockMutex(timeoutType, lockTimeout);
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t MessageQueue::unlockQueue() {
|
||||||
|
return queueLock->unlockMutex();
|
||||||
|
}
|
231
osal/host/MessageQueue.h
Normal file
231
osal/host/MessageQueue.h
Normal file
@ -0,0 +1,231 @@
|
|||||||
|
#ifndef FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
|
||||||
|
#define FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
|
||||||
|
|
||||||
|
#include "../../internalError/InternalErrorReporterIF.h"
|
||||||
|
#include "../../ipc/MessageQueueIF.h"
|
||||||
|
#include "../../ipc/MessageQueueMessage.h"
|
||||||
|
#include "../../ipc/MutexIF.h"
|
||||||
|
#include "../../timemanager/Clock.h"
|
||||||
|
|
||||||
|
#include <queue>
|
||||||
|
#include <memory>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This class manages sending and receiving of
|
||||||
|
* message queue messages.
|
||||||
|
* @details
|
||||||
|
* Message queues are used to pass asynchronous messages between processes.
|
||||||
|
* They work like post boxes, where all incoming messages are stored in FIFO
|
||||||
|
* order. This class creates a new receiving queue and provides methods to fetch
|
||||||
|
* received messages. Being a child of MessageQueueSender, this class also
|
||||||
|
* provides methods to send a message to a user-defined or a default destination.
|
||||||
|
* In addition it also provides a reply method to answer to the queue it
|
||||||
|
* received its last message from.
|
||||||
|
*
|
||||||
|
* The MessageQueue should be used as "post box" for a single owning object.
|
||||||
|
* So all message queue communication is "n-to-one".
|
||||||
|
* For creating the queue, as well as sending and receiving messages, the class
|
||||||
|
* makes use of the operating system calls provided.
|
||||||
|
*
|
||||||
|
* Please keep in mind that FreeRTOS offers different calls for message queue
|
||||||
|
* operations if called from an ISR.
|
||||||
|
* For now, the system context needs to be switched manually.
|
||||||
|
* @ingroup osal
|
||||||
|
* @ingroup message_queue
|
||||||
|
*/
|
||||||
|
class MessageQueue : public MessageQueueIF {
|
||||||
|
friend class MessageQueueSenderIF;
|
||||||
|
public:
|
||||||
|
/**
|
||||||
|
* @brief The constructor initializes and configures the message queue.
|
||||||
|
* @details
|
||||||
|
* By making use of the according operating system call, a message queue is
|
||||||
|
* created and initialized. The message depth - the maximum number of
|
||||||
|
* messages to be buffered - may be set with the help of a parameter,
|
||||||
|
* whereas the message size is automatically set to the maximum message
|
||||||
|
* queue message size. The operating system sets the message queue id, or
|
||||||
|
* in case of failure, it is set to zero.
|
||||||
|
* @param message_depth
|
||||||
|
* The number of messages to be buffered before passing an error to the
|
||||||
|
* sender. Default is three.
|
||||||
|
* @param max_message_size
|
||||||
|
* With this parameter, the maximum message size can be adjusted.
|
||||||
|
* This should be left default.
|
||||||
|
*/
|
||||||
|
MessageQueue(size_t messageDepth = 3,
|
||||||
|
size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
|
||||||
|
|
||||||
|
/** Copying message queues forbidden */
|
||||||
|
MessageQueue(const MessageQueue&) = delete;
|
||||||
|
MessageQueue& operator=(const MessageQueue&) = delete;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief The destructor deletes the formerly created message queue.
|
||||||
|
* @details This is accomplished by using the delete call provided
|
||||||
|
* by the operating system.
|
||||||
|
*/
|
||||||
|
virtual ~MessageQueue();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This operation sends a message to the given destination.
|
||||||
|
* @details It directly uses the sendMessage call of the MessageQueueSender
|
||||||
|
* parent, but passes its queue id as "sentFrom" parameter.
|
||||||
|
* @param sendTo This parameter specifies the message queue id of the
|
||||||
|
* destination message queue.
|
||||||
|
* @param message A pointer to a previously created message, which is sent.
|
||||||
|
* @param ignoreFault If set to true, the internal software fault counter
|
||||||
|
* is not incremented if queue is full.
|
||||||
|
*/
|
||||||
|
ReturnValue_t sendMessage(MessageQueueId_t sendTo,
|
||||||
|
MessageQueueMessageIF* message, bool ignoreFault = false) override;
|
||||||
|
/**
|
||||||
|
* @brief This operation sends a message to the default destination.
|
||||||
|
* @details As in the sendMessage method, this function uses the
|
||||||
|
* sendToDefault call of the MessageQueueSender parent class and adds its
|
||||||
|
* queue id as "sentFrom" information.
|
||||||
|
* @param message A pointer to a previously created message, which is sent.
|
||||||
|
*/
|
||||||
|
ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
|
||||||
|
/**
|
||||||
|
* @brief This operation sends a message to the last communication partner.
|
||||||
|
* @details This operation simplifies answering an incoming message by using
|
||||||
|
* the stored lastPartner information as destination. If there was no
|
||||||
|
* message received yet (i.e. lastPartner is zero), an error code is returned.
|
||||||
|
* @param message A pointer to a previously created message, which is sent.
|
||||||
|
*/
|
||||||
|
ReturnValue_t reply(MessageQueueMessageIF* message) override;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief With the sendMessage call, a queue message is sent to a
|
||||||
|
* receiving queue.
|
||||||
|
* @details
|
||||||
|
* This method takes the message provided, adds the sentFrom information and
|
||||||
|
* passes it on to the destination provided with an operating system call.
|
||||||
|
* The OS's return value is returned.
|
||||||
|
* @param sendTo This parameter specifies the message queue id to send
|
||||||
|
* the message to.
|
||||||
|
* @param message This is a pointer to a previously created message,
|
||||||
|
* which is sent.
|
||||||
|
* @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.
|
||||||
|
* @param ignoreFault If set to true, the internal software fault counter
|
||||||
|
* is not incremented if queue is full.
|
||||||
|
*/
|
||||||
|
virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
|
||||||
|
MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
|
||||||
|
bool ignoreFault = false) override;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief The sendToDefault method sends a queue message to the default
|
||||||
|
* destination.
|
||||||
|
* @details
|
||||||
|
* In all other aspects, it works identical to the sendMessage method.
|
||||||
|
* @param message This is a pointer to a previously created message,
|
||||||
|
* which is sent.
|
||||||
|
* @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.
|
||||||
|
*/
|
||||||
|
virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
|
||||||
|
MessageQueueId_t sentFrom = NO_QUEUE,
|
||||||
|
bool ignoreFault = false) override;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This function reads available messages from the message queue
|
||||||
|
* and returns the sender.
|
||||||
|
* @details
|
||||||
|
* It works identically to the other receiveMessage call, but in addition
|
||||||
|
* returns the sender's queue id.
|
||||||
|
* @param message A pointer to a message in which the received data is stored.
|
||||||
|
* @param receivedFrom A pointer to a queue id in which the sender's id is stored.
|
||||||
|
*/
|
||||||
|
ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
|
||||||
|
MessageQueueId_t *receivedFrom) override;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This function reads available messages from the message queue.
|
||||||
|
* @details
|
||||||
|
* If data is available it is stored in the passed message pointer.
|
||||||
|
* The message's original content is overwritten and the sendFrom
|
||||||
|
* information is stored in the lastPartner attribute. Else, the lastPartner
|
||||||
|
* information remains untouched, the message's content is cleared and the
|
||||||
|
* function returns immediately.
|
||||||
|
* @param message A pointer to a message in which the received data is stored.
|
||||||
|
*/
|
||||||
|
ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
|
||||||
|
/**
|
||||||
|
* Deletes all pending messages in the queue.
|
||||||
|
* @param count The number of flushed messages.
|
||||||
|
* @return RETURN_OK on success.
|
||||||
|
*/
|
||||||
|
ReturnValue_t flush(uint32_t* count) override;
|
||||||
|
/**
|
||||||
|
* @brief This method returns the message queue id of the last
|
||||||
|
* communication partner.
|
||||||
|
*/
|
||||||
|
MessageQueueId_t getLastPartner() const override;
|
||||||
|
/**
|
||||||
|
* @brief This method returns the message queue id of this class's
|
||||||
|
* message queue.
|
||||||
|
*/
|
||||||
|
MessageQueueId_t getId() const override;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This method is a simple setter for the default destination.
|
||||||
|
*/
|
||||||
|
void setDefaultDestination(MessageQueueId_t defaultDestination) override;
|
||||||
|
/**
|
||||||
|
* @brief This method is a simple getter for the default destination.
|
||||||
|
*/
|
||||||
|
MessageQueueId_t getDefaultDestination() const override;
|
||||||
|
|
||||||
|
bool isDefaultDestinationSet() const override;
|
||||||
|
|
||||||
|
ReturnValue_t lockQueue(MutexIF::TimeoutType timeoutType,
|
||||||
|
dur_millis_t lockTimeout);
|
||||||
|
ReturnValue_t unlockQueue();
|
||||||
|
protected:
|
||||||
|
/**
|
||||||
|
* @brief Implementation to be called from any send Call within
|
||||||
|
* MessageQueue and MessageQueueSenderIF.
|
||||||
|
* @details
|
||||||
|
* This method takes the message provided, adds the sentFrom information and
|
||||||
|
* passes it on to the destination provided with an operating system call.
|
||||||
|
* The OS's return value is returned.
|
||||||
|
* @param sendTo
|
||||||
|
* This parameter specifies the message queue id to send the message to.
|
||||||
|
* @param message
|
||||||
|
* This is a pointer to a previously created message, which is sent.
|
||||||
|
* @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.
|
||||||
|
* @param ignoreFault
|
||||||
|
* If set to true, the internal software fault counter is not incremented
|
||||||
|
* if queue is full.
|
||||||
|
* @param context Specify whether call is made from task or from an ISR.
|
||||||
|
*/
|
||||||
|
static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
|
||||||
|
MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
|
||||||
|
bool ignoreFault=false);
|
||||||
|
|
||||||
|
//static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
|
||||||
|
|
||||||
|
private:
|
||||||
|
std::queue<MessageQueueMessage> messageQueue;
|
||||||
|
/**
|
||||||
|
* @brief The class stores the queue id it got assigned.
|
||||||
|
* If initialization fails, the queue id is set to zero.
|
||||||
|
*/
|
||||||
|
MessageQueueId_t mqId = 0;
|
||||||
|
size_t messageSize = 0;
|
||||||
|
size_t messageDepth = 0;
|
||||||
|
|
||||||
|
MutexIF* queueLock;
|
||||||
|
|
||||||
|
bool defaultDestinationSet = false;
|
||||||
|
MessageQueueId_t defaultDestination = 0;
|
||||||
|
MessageQueueId_t lastPartner = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */
|
39
osal/host/Mutex.cpp
Normal file
39
osal/host/Mutex.cpp
Normal file
@ -0,0 +1,39 @@
|
|||||||
|
#include "Mutex.h"
|
||||||
|
#include "../../serviceinterface/ServiceInterfaceStream.h"
|
||||||
|
|
||||||
|
Mutex::Mutex() {}
|
||||||
|
|
||||||
|
ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
|
||||||
|
if(timeoutMs == MutexIF::BLOCKING) {
|
||||||
|
mutex.lock();
|
||||||
|
locked = true;
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
else if(timeoutMs == MutexIF::POLLING) {
|
||||||
|
if(mutex.try_lock()) {
|
||||||
|
locked = true;
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if(timeoutMs > MutexIF::POLLING){
|
||||||
|
auto chronoMs = std::chrono::milliseconds(timeoutMs);
|
||||||
|
if(mutex.try_lock_for(chronoMs)) {
|
||||||
|
locked = true;
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return MutexIF::MUTEX_TIMEOUT;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t Mutex::unlockMutex() {
|
||||||
|
if(not locked) {
|
||||||
|
return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
|
||||||
|
}
|
||||||
|
mutex.unlock();
|
||||||
|
locked = false;
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::timed_mutex* Mutex::getMutexHandle() {
|
||||||
|
return &mutex;
|
||||||
|
}
|
29
osal/host/Mutex.h
Normal file
29
osal/host/Mutex.h
Normal file
@ -0,0 +1,29 @@
|
|||||||
|
#ifndef FSFW_OSAL_HOSTED_MUTEX_H_
|
||||||
|
#define FSFW_OSAL_HOSTED_MUTEX_H_
|
||||||
|
|
||||||
|
#include "../../ipc/MutexIF.h"
|
||||||
|
|
||||||
|
#include <mutex>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief OS component to implement MUTual EXclusion
|
||||||
|
*
|
||||||
|
* @details
|
||||||
|
* Mutexes are binary semaphores which include a priority inheritance mechanism.
|
||||||
|
* Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
|
||||||
|
* @ingroup osal
|
||||||
|
*/
|
||||||
|
class Mutex : public MutexIF {
|
||||||
|
public:
|
||||||
|
Mutex();
|
||||||
|
ReturnValue_t lockMutex(TimeoutType timeoutType =
|
||||||
|
TimeoutType::BLOCKING, uint32_t timeoutMs = 0) override;
|
||||||
|
ReturnValue_t unlockMutex() override;
|
||||||
|
|
||||||
|
std::timed_mutex* getMutexHandle();
|
||||||
|
private:
|
||||||
|
bool locked = false;
|
||||||
|
std::timed_mutex mutex;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif /* FSFW_OSAL_HOSTED_MUTEX_H_ */
|
28
osal/host/MutexFactory.cpp
Normal file
28
osal/host/MutexFactory.cpp
Normal file
@ -0,0 +1,28 @@
|
|||||||
|
#include "../../ipc/MutexFactory.h"
|
||||||
|
#include "../../osal/host/Mutex.h"
|
||||||
|
|
||||||
|
//TODO: Different variant than the lazy loading in QueueFactory.
|
||||||
|
//What's better and why? -> one is on heap the other on bss/data
|
||||||
|
//MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
|
||||||
|
MutexFactory* MutexFactory::factoryInstance = nullptr;
|
||||||
|
|
||||||
|
MutexFactory::MutexFactory() {
|
||||||
|
}
|
||||||
|
|
||||||
|
MutexFactory::~MutexFactory() {
|
||||||
|
}
|
||||||
|
|
||||||
|
MutexFactory* MutexFactory::instance() {
|
||||||
|
if (factoryInstance == nullptr){
|
||||||
|
factoryInstance = new MutexFactory();
|
||||||
|
}
|
||||||
|
return MutexFactory::factoryInstance;
|
||||||
|
}
|
||||||
|
|
||||||
|
MutexIF* MutexFactory::createMutex() {
|
||||||
|
return new Mutex();
|
||||||
|
}
|
||||||
|
|
||||||
|
void MutexFactory::deleteMutex(MutexIF* mutex) {
|
||||||
|
delete mutex;
|
||||||
|
}
|
176
osal/host/PeriodicTask.cpp
Normal file
176
osal/host/PeriodicTask.cpp
Normal file
@ -0,0 +1,176 @@
|
|||||||
|
#include "Mutex.h"
|
||||||
|
#include "PeriodicTask.h"
|
||||||
|
|
||||||
|
#include "../../ipc/MutexFactory.h"
|
||||||
|
#include "../../serviceinterface/ServiceInterfaceStream.h"
|
||||||
|
#include "../../tasks/ExecutableObjectIF.h"
|
||||||
|
|
||||||
|
#include <thread>
|
||||||
|
#include <chrono>
|
||||||
|
|
||||||
|
#if defined(WIN32)
|
||||||
|
#include <windows.h>
|
||||||
|
#elif defined(LINUX)
|
||||||
|
#include <pthread.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
|
||||||
|
TaskStackSize setStack, TaskPeriod setPeriod,
|
||||||
|
void (*setDeadlineMissedFunc)()) :
|
||||||
|
started(false), taskName(name), period(setPeriod),
|
||||||
|
deadlineMissedFunc(setDeadlineMissedFunc) {
|
||||||
|
// It is propably possible to set task priorities by using the native
|
||||||
|
// task handles for Windows / Linux
|
||||||
|
mainThread = std::thread(&PeriodicTask::taskEntryPoint, this, this);
|
||||||
|
#if defined(WIN32)
|
||||||
|
/* List of possible priority classes:
|
||||||
|
* https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
|
||||||
|
* nf-processthreadsapi-setpriorityclass
|
||||||
|
* And respective thread priority numbers:
|
||||||
|
* https://docs.microsoft.com/en-us/windows/
|
||||||
|
* win32/procthread/scheduling-priorities */
|
||||||
|
int result = SetPriorityClass(
|
||||||
|
reinterpret_cast<HANDLE>(mainThread.native_handle()),
|
||||||
|
ABOVE_NORMAL_PRIORITY_CLASS);
|
||||||
|
if(result != 0) {
|
||||||
|
sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
|
||||||
|
<< GetLastError() << std::endl;
|
||||||
|
}
|
||||||
|
result = SetThreadPriority(
|
||||||
|
reinterpret_cast<HANDLE>(mainThread.native_handle()),
|
||||||
|
THREAD_PRIORITY_NORMAL);
|
||||||
|
if(result != 0) {
|
||||||
|
sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
|
||||||
|
<< GetLastError() << std::endl;
|
||||||
|
}
|
||||||
|
#elif defined(LINUX)
|
||||||
|
// we can just copy and paste the code from linux here.
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
PeriodicTask::~PeriodicTask(void) {
|
||||||
|
//Do not delete objects, we were responsible for ptrs only.
|
||||||
|
terminateThread = true;
|
||||||
|
if(mainThread.joinable()) {
|
||||||
|
mainThread.join();
|
||||||
|
}
|
||||||
|
delete this;
|
||||||
|
}
|
||||||
|
|
||||||
|
void PeriodicTask::taskEntryPoint(void* argument) {
|
||||||
|
PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
|
||||||
|
|
||||||
|
|
||||||
|
if (not originalTask->started) {
|
||||||
|
// we have to suspend/block here until the task is started.
|
||||||
|
// if semaphores are implemented, use them here.
|
||||||
|
std::unique_lock<std::mutex> lock(initMutex);
|
||||||
|
initCondition.wait(lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
this->taskFunctionality();
|
||||||
|
sif::debug << "PeriodicTask::taskEntryPoint: "
|
||||||
|
"Returned from taskFunctionality." << std::endl;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t PeriodicTask::startTask() {
|
||||||
|
started = true;
|
||||||
|
|
||||||
|
// Notify task to start.
|
||||||
|
std::lock_guard<std::mutex> lock(initMutex);
|
||||||
|
initCondition.notify_one();
|
||||||
|
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
|
||||||
|
std::this_thread::sleep_for(std::chrono::milliseconds(ms));
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
void PeriodicTask::taskFunctionality() {
|
||||||
|
std::chrono::milliseconds periodChrono(static_cast<uint32_t>(period*1000));
|
||||||
|
auto currentStartTime {
|
||||||
|
std::chrono::duration_cast<std::chrono::milliseconds>(
|
||||||
|
std::chrono::system_clock::now().time_since_epoch())
|
||||||
|
};
|
||||||
|
auto nextStartTime{ currentStartTime };
|
||||||
|
|
||||||
|
/* Enter the loop that defines the task behavior. */
|
||||||
|
for (;;) {
|
||||||
|
if(terminateThread.load()) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
for (ObjectList::iterator it = objectList.begin();
|
||||||
|
it != objectList.end(); ++it) {
|
||||||
|
(*it)->performOperation();
|
||||||
|
}
|
||||||
|
if(not delayForInterval(¤tStartTime, periodChrono)) {
|
||||||
|
sif::warning << "PeriodicTask: " << taskName <<
|
||||||
|
" missed deadline!\n" << std::flush;
|
||||||
|
if(deadlineMissedFunc != nullptr) {
|
||||||
|
this->deadlineMissedFunc();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
|
||||||
|
ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
|
||||||
|
object);
|
||||||
|
if (newObject == nullptr) {
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
objectList.push_back(newObject);
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t PeriodicTask::getPeriodMs() const {
|
||||||
|
return period * 1000;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool PeriodicTask::delayForInterval(chron_ms* previousWakeTimeMs,
|
||||||
|
const chron_ms interval) {
|
||||||
|
bool shouldDelay = false;
|
||||||
|
//Get current wakeup time
|
||||||
|
auto currentStartTime =
|
||||||
|
std::chrono::duration_cast<std::chrono::milliseconds>(
|
||||||
|
std::chrono::system_clock::now().time_since_epoch());
|
||||||
|
/* Generate the tick time at which the task wants to wake. */
|
||||||
|
auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
|
||||||
|
|
||||||
|
if (currentStartTime < *previousWakeTimeMs) {
|
||||||
|
/* The tick count has overflowed since this function was
|
||||||
|
lasted called. In this case the only time we should ever
|
||||||
|
actually delay is if the wake time has also overflowed,
|
||||||
|
and the wake time is greater than the tick time. When this
|
||||||
|
is the case it is as if neither time had overflowed. */
|
||||||
|
if ((nextTimeToWake_ms < *previousWakeTimeMs)
|
||||||
|
&& (nextTimeToWake_ms > currentStartTime)) {
|
||||||
|
shouldDelay = true;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
/* The tick time has not overflowed. In this case we will
|
||||||
|
delay if either the wake time has overflowed, and/or the
|
||||||
|
tick time is less than the wake time. */
|
||||||
|
if ((nextTimeToWake_ms < *previousWakeTimeMs)
|
||||||
|
|| (nextTimeToWake_ms > currentStartTime)) {
|
||||||
|
shouldDelay = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Update the wake time ready for the next call. */
|
||||||
|
|
||||||
|
(*previousWakeTimeMs) = nextTimeToWake_ms;
|
||||||
|
|
||||||
|
if (shouldDelay) {
|
||||||
|
auto sleepTime = std::chrono::duration_cast<std::chrono::milliseconds>(
|
||||||
|
nextTimeToWake_ms - currentStartTime);
|
||||||
|
std::this_thread::sleep_for(sleepTime);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
//We are shifting the time in case the deadline was missed like rtems
|
||||||
|
(*previousWakeTimeMs) = currentStartTime;
|
||||||
|
return false;
|
||||||
|
|
||||||
|
}
|
123
osal/host/PeriodicTask.h
Normal file
123
osal/host/PeriodicTask.h
Normal file
@ -0,0 +1,123 @@
|
|||||||
|
#ifndef FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
|
||||||
|
#define FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
|
||||||
|
|
||||||
|
#include "../../objectmanager/ObjectManagerIF.h"
|
||||||
|
#include "../../tasks/PeriodicTaskIF.h"
|
||||||
|
#include "../../tasks/Typedef.h"
|
||||||
|
|
||||||
|
#include <vector>
|
||||||
|
#include <thread>
|
||||||
|
#include <condition_variable>
|
||||||
|
#include <atomic>
|
||||||
|
|
||||||
|
class ExecutableObjectIF;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This class represents a specialized task for
|
||||||
|
* periodic activities of multiple objects.
|
||||||
|
* @details
|
||||||
|
*
|
||||||
|
* @ingroup task_handling
|
||||||
|
*/
|
||||||
|
class PeriodicTask: public PeriodicTaskIF {
|
||||||
|
public:
|
||||||
|
/**
|
||||||
|
* @brief Standard constructor of the class.
|
||||||
|
* @details
|
||||||
|
* The class is initialized without allocated objects. These need to be
|
||||||
|
* added with #addComponent.
|
||||||
|
* @param priority
|
||||||
|
* @param stack_size
|
||||||
|
* @param setPeriod
|
||||||
|
* @param setDeadlineMissedFunc
|
||||||
|
* The function pointer to the deadline missed function that shall be
|
||||||
|
* assigned.
|
||||||
|
*/
|
||||||
|
PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack,
|
||||||
|
TaskPeriod setPeriod,void (*setDeadlineMissedFunc)());
|
||||||
|
/**
|
||||||
|
* @brief Currently, the executed object's lifetime is not coupled with
|
||||||
|
* the task object's lifetime, so the destructor is empty.
|
||||||
|
*/
|
||||||
|
virtual ~PeriodicTask(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief The method to start the task.
|
||||||
|
* @details The method starts the task with the respective system call.
|
||||||
|
* Entry point is the taskEntryPoint method described below.
|
||||||
|
* The address of the task object is passed as an argument
|
||||||
|
* to the system call.
|
||||||
|
*/
|
||||||
|
ReturnValue_t startTask(void);
|
||||||
|
/**
|
||||||
|
* Adds an object to the list of objects to be executed.
|
||||||
|
* The objects are executed in the order added.
|
||||||
|
* @param object Id of the object to add.
|
||||||
|
* @return
|
||||||
|
* -@c RETURN_OK on success
|
||||||
|
* -@c RETURN_FAILED if the object could not be added.
|
||||||
|
*/
|
||||||
|
ReturnValue_t addComponent(object_id_t object);
|
||||||
|
|
||||||
|
uint32_t getPeriodMs() const;
|
||||||
|
|
||||||
|
ReturnValue_t sleepFor(uint32_t ms);
|
||||||
|
|
||||||
|
protected:
|
||||||
|
using chron_ms = std::chrono::milliseconds;
|
||||||
|
bool started;
|
||||||
|
//!< Typedef for the List of objects.
|
||||||
|
typedef std::vector<ExecutableObjectIF*> ObjectList;
|
||||||
|
std::thread mainThread;
|
||||||
|
std::atomic<bool> terminateThread = false;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief This attribute holds a list of objects to be executed.
|
||||||
|
*/
|
||||||
|
ObjectList objectList;
|
||||||
|
|
||||||
|
std::condition_variable initCondition;
|
||||||
|
std::mutex initMutex;
|
||||||
|
std::string taskName;
|
||||||
|
/**
|
||||||
|
* @brief The period of the task.
|
||||||
|
* @details
|
||||||
|
* The period determines the frequency of the task's execution.
|
||||||
|
* It is expressed in clock ticks.
|
||||||
|
*/
|
||||||
|
TaskPeriod period;
|
||||||
|
/**
|
||||||
|
* @brief The pointer to the deadline-missed function.
|
||||||
|
* @details
|
||||||
|
* This pointer stores the function that is executed if the task's deadline
|
||||||
|
* is missed. So, each may react individually on a timing failure.
|
||||||
|
* The pointer may be NULL, then nothing happens on missing the deadline.
|
||||||
|
* The deadline is equal to the next execution of the periodic task.
|
||||||
|
*/
|
||||||
|
void (*deadlineMissedFunc)(void);
|
||||||
|
/**
|
||||||
|
* @brief This is the function executed in the new task's context.
|
||||||
|
* @details
|
||||||
|
* It converts the argument back to the thread object type and copies the
|
||||||
|
* class instance to the task context.
|
||||||
|
* The taskFunctionality method is called afterwards.
|
||||||
|
* @param A pointer to the task object itself is passed as argument.
|
||||||
|
*/
|
||||||
|
|
||||||
|
void taskEntryPoint(void* argument);
|
||||||
|
/**
|
||||||
|
* @brief The function containing the actual functionality of the task.
|
||||||
|
* @details
|
||||||
|
* The method sets and starts the task's period, then enters a loop that is
|
||||||
|
* repeated as long as the isRunning attribute is true. Within the loop,
|
||||||
|
* all performOperation methods of the added objects are called. Afterwards
|
||||||
|
* the checkAndRestartPeriod system call blocks the task until the next
|
||||||
|
* period. On missing the deadline, the deadlineMissedFunction is executed.
|
||||||
|
*/
|
||||||
|
void taskFunctionality(void);
|
||||||
|
|
||||||
|
bool delayForInterval(chron_ms * previousWakeTimeMs,
|
||||||
|
const chron_ms interval);
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif /* PERIODICTASK_H_ */
|
41
osal/host/QueueFactory.cpp
Normal file
41
osal/host/QueueFactory.cpp
Normal file
@ -0,0 +1,41 @@
|
|||||||
|
#include "../../ipc/QueueFactory.h"
|
||||||
|
#include "../../osal/host/MessageQueue.h"
|
||||||
|
#include "../../serviceinterface/ServiceInterfaceStream.h"
|
||||||
|
#include <cstring>
|
||||||
|
|
||||||
|
QueueFactory* QueueFactory::factoryInstance = nullptr;
|
||||||
|
|
||||||
|
|
||||||
|
ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
|
||||||
|
MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
|
||||||
|
bool ignoreFault) {
|
||||||
|
return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
|
||||||
|
sentFrom,ignoreFault);
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
QueueFactory* QueueFactory::instance() {
|
||||||
|
if (factoryInstance == nullptr) {
|
||||||
|
factoryInstance = new QueueFactory;
|
||||||
|
}
|
||||||
|
return factoryInstance;
|
||||||
|
}
|
||||||
|
|
||||||
|
QueueFactory::QueueFactory() {
|
||||||
|
}
|
||||||
|
|
||||||
|
QueueFactory::~QueueFactory() {
|
||||||
|
}
|
||||||
|
|
||||||
|
MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
|
||||||
|
size_t maxMessageSize) {
|
||||||
|
// A thread-safe queue can be implemented by using a combination
|
||||||
|
// of std::queue and std::mutex. This uses dynamic memory allocation
|
||||||
|
// which could be alleviated by using a custom allocator, external library
|
||||||
|
// (etl::queue) or simply using std::queue, we're on a host machine anyway.
|
||||||
|
return new MessageQueue(messageDepth, maxMessageSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
|
||||||
|
delete queue;
|
||||||
|
}
|
52
osal/host/QueueMapManager.cpp
Normal file
52
osal/host/QueueMapManager.cpp
Normal file
@ -0,0 +1,52 @@
|
|||||||
|
#include "QueueMapManager.h"
|
||||||
|
|
||||||
|
#include "../../ipc/MutexFactory.h"
|
||||||
|
#include "../../ipc/MutexHelper.h"
|
||||||
|
|
||||||
|
QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
|
||||||
|
|
||||||
|
QueueMapManager::QueueMapManager() {
|
||||||
|
mapLock = MutexFactory::instance()->createMutex();
|
||||||
|
}
|
||||||
|
|
||||||
|
QueueMapManager* QueueMapManager::instance() {
|
||||||
|
if (mqManagerInstance == nullptr){
|
||||||
|
mqManagerInstance = new QueueMapManager();
|
||||||
|
}
|
||||||
|
return QueueMapManager::mqManagerInstance;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t QueueMapManager::addMessageQueue(
|
||||||
|
MessageQueueIF* queueToInsert, MessageQueueId_t* id) {
|
||||||
|
// Not thread-safe, but it is assumed all message queues are created
|
||||||
|
// at software initialization now. If this is to be made thread-safe in
|
||||||
|
// the future, it propably would be sufficient to lock the increment
|
||||||
|
// operation here
|
||||||
|
uint32_t currentId = queueCounter++;
|
||||||
|
auto returnPair = queueMap.emplace(currentId, queueToInsert);
|
||||||
|
if(not returnPair.second) {
|
||||||
|
// this should never happen for the atomic variable.
|
||||||
|
sif::error << "QueueMapManager: This ID is already inside the map!"
|
||||||
|
<< std::endl;
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
if (id != nullptr) {
|
||||||
|
*id = currentId;
|
||||||
|
}
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
MessageQueueIF* QueueMapManager::getMessageQueue(
|
||||||
|
MessageQueueId_t messageQueueId) const {
|
||||||
|
MutexHelper(mapLock, MutexIF::TimeoutType::WAITING, 50);
|
||||||
|
auto queueIter = queueMap.find(messageQueueId);
|
||||||
|
if(queueIter != queueMap.end()) {
|
||||||
|
return queueIter->second;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
sif::warning << "QueueMapManager::getQueueHandle: The ID" <<
|
||||||
|
messageQueueId << " does not exists in the map" << std::endl;
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
47
osal/host/QueueMapManager.h
Normal file
47
osal/host/QueueMapManager.h
Normal file
@ -0,0 +1,47 @@
|
|||||||
|
#ifndef FSFW_OSAL_HOST_QUEUEMAPMANAGER_H_
|
||||||
|
#define FSFW_OSAL_HOST_QUEUEMAPMANAGER_H_
|
||||||
|
|
||||||
|
#include "../../ipc/MessageQueueSenderIF.h"
|
||||||
|
#include "../../osal/host/MessageQueue.h"
|
||||||
|
#include <unordered_map>
|
||||||
|
#include <atomic>
|
||||||
|
|
||||||
|
using QueueMap = std::unordered_map<MessageQueueId_t, MessageQueueIF*>;
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* An internal map to map message queue IDs to message queues.
|
||||||
|
* This propably should be a singleton..
|
||||||
|
*/
|
||||||
|
class QueueMapManager {
|
||||||
|
public:
|
||||||
|
//! Returns the single instance of SemaphoreFactory.
|
||||||
|
static QueueMapManager* instance();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Insert a message queue into the map and returns a message queue ID
|
||||||
|
* @param queue The message queue to insert.
|
||||||
|
* @param id The passed value will be set unless a nullptr is passed
|
||||||
|
* @return
|
||||||
|
*/
|
||||||
|
ReturnValue_t addMessageQueue(MessageQueueIF* queue, MessageQueueId_t*
|
||||||
|
id = nullptr);
|
||||||
|
/**
|
||||||
|
* Get the message queue handle by providing a message queue ID.
|
||||||
|
* @param messageQueueId
|
||||||
|
* @return
|
||||||
|
*/
|
||||||
|
MessageQueueIF* getMessageQueue(MessageQueueId_t messageQueueId) const;
|
||||||
|
|
||||||
|
private:
|
||||||
|
//! External instantiation is forbidden.
|
||||||
|
QueueMapManager();
|
||||||
|
uint32_t queueCounter = 1;
|
||||||
|
MutexIF* mapLock;
|
||||||
|
QueueMap queueMap;
|
||||||
|
static QueueMapManager* mqManagerInstance;
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#endif /* FSFW_OSAL_HOST_QUEUEMAPMANAGER_H_ */
|
39
osal/host/SemaphoreFactory.cpp
Normal file
39
osal/host/SemaphoreFactory.cpp
Normal file
@ -0,0 +1,39 @@
|
|||||||
|
#include "../../tasks/SemaphoreFactory.h"
|
||||||
|
#include "../../osal/linux/BinarySemaphore.h"
|
||||||
|
#include "../../osal/linux/CountingSemaphore.h"
|
||||||
|
#include "../../serviceinterface/ServiceInterfaceStream.h"
|
||||||
|
|
||||||
|
SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
|
||||||
|
|
||||||
|
SemaphoreFactory::SemaphoreFactory() {
|
||||||
|
}
|
||||||
|
|
||||||
|
SemaphoreFactory::~SemaphoreFactory() {
|
||||||
|
delete factoryInstance;
|
||||||
|
}
|
||||||
|
|
||||||
|
SemaphoreFactory* SemaphoreFactory::instance() {
|
||||||
|
if (factoryInstance == nullptr){
|
||||||
|
factoryInstance = new SemaphoreFactory();
|
||||||
|
}
|
||||||
|
return SemaphoreFactory::factoryInstance;
|
||||||
|
}
|
||||||
|
|
||||||
|
SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
|
||||||
|
// Just gonna wait for full C++20 for now.
|
||||||
|
sif::error << "SemaphoreFactory: Binary Semaphore not implemented yet."
|
||||||
|
" Returning nullptr!\n" << std::flush;
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
|
||||||
|
uint8_t initCount, uint32_t arguments) {
|
||||||
|
// Just gonna wait for full C++20 for now.
|
||||||
|
sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
|
||||||
|
" Returning nullptr!\n" << std::flush;
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
|
||||||
|
delete semaphore;
|
||||||
|
}
|
51
osal/host/TaskFactory.cpp
Normal file
51
osal/host/TaskFactory.cpp
Normal file
@ -0,0 +1,51 @@
|
|||||||
|
#include "../../osal/host/FixedTimeslotTask.h"
|
||||||
|
#include "../../osal/host/PeriodicTask.h"
|
||||||
|
#include "../../tasks/TaskFactory.h"
|
||||||
|
#include "../../returnvalues/HasReturnvaluesIF.h"
|
||||||
|
#include "../../tasks/PeriodicTaskIF.h"
|
||||||
|
|
||||||
|
#include <chrono>
|
||||||
|
|
||||||
|
TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
|
||||||
|
|
||||||
|
// Will propably not be used for hosted implementation
|
||||||
|
const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = 0;
|
||||||
|
|
||||||
|
TaskFactory::TaskFactory() {
|
||||||
|
}
|
||||||
|
|
||||||
|
TaskFactory::~TaskFactory() {
|
||||||
|
}
|
||||||
|
|
||||||
|
TaskFactory* TaskFactory::instance() {
|
||||||
|
return TaskFactory::factoryInstance;
|
||||||
|
}
|
||||||
|
|
||||||
|
PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
|
||||||
|
TaskPriority taskPriority_,TaskStackSize stackSize_,
|
||||||
|
TaskPeriod periodInSeconds_,
|
||||||
|
TaskDeadlineMissedFunction deadLineMissedFunction_) {
|
||||||
|
return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
|
||||||
|
deadLineMissedFunction_);
|
||||||
|
}
|
||||||
|
|
||||||
|
FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
|
||||||
|
TaskPriority taskPriority_,TaskStackSize stackSize_,
|
||||||
|
TaskPeriod periodInSeconds_,
|
||||||
|
TaskDeadlineMissedFunction deadLineMissedFunction_) {
|
||||||
|
return new FixedTimeslotTask(name_, taskPriority_, stackSize_,
|
||||||
|
periodInSeconds_, deadLineMissedFunction_);
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
|
||||||
|
// This might block for some time!
|
||||||
|
delete task;
|
||||||
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
|
||||||
|
std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
|
||||||
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
@ -5,8 +5,8 @@
|
|||||||
|
|
||||||
PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
|
PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
|
||||||
size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
|
size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
|
||||||
PosixThread(name_,priority_,stackSize_),objectList(),started(false),
|
PosixThread(name_, priority_, stackSize_), objectList(), started(false),
|
||||||
periodMs(period_),deadlineMissedFunc(deadlineMissedFunc_) {
|
periodMs(period_), deadlineMissedFunc(deadlineMissedFunc_) {
|
||||||
}
|
}
|
||||||
|
|
||||||
PeriodicPosixTask::~PeriodicPosixTask() {
|
PeriodicPosixTask::~PeriodicPosixTask() {
|
||||||
@ -25,6 +25,8 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
|
|||||||
ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
|
ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
|
||||||
object);
|
object);
|
||||||
if (newObject == nullptr) {
|
if (newObject == nullptr) {
|
||||||
|
sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
|
||||||
|
<< " it implements ExecutableObjectIF!" << std::endl;
|
||||||
return HasReturnvaluesIF::RETURN_FAILED;
|
return HasReturnvaluesIF::RETURN_FAILED;
|
||||||
}
|
}
|
||||||
objectList.push_back(newObject);
|
objectList.push_back(newObject);
|
||||||
@ -38,35 +40,41 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
ReturnValue_t PeriodicPosixTask::startTask(void){
|
ReturnValue_t PeriodicPosixTask::startTask(void) {
|
||||||
started = true;
|
started = true;
|
||||||
//sif::info << stackSize << std::endl;
|
//sif::info << stackSize << std::endl;
|
||||||
PosixThread::createTask(&taskEntryPoint,this);
|
PosixThread::createTask(&taskEntryPoint,this);
|
||||||
return HasReturnvaluesIF::RETURN_OK;
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
}
|
}
|
||||||
|
|
||||||
void PeriodicPosixTask::taskFunctionality(void){
|
void PeriodicPosixTask::taskFunctionality(void) {
|
||||||
if(!started){
|
if(not started) {
|
||||||
suspend();
|
suspend();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
for (auto const &object: objectList) {
|
||||||
|
object->initializeAfterTaskCreation();
|
||||||
|
}
|
||||||
|
|
||||||
uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
|
uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
|
||||||
//The task's "infinite" inner loop is entered.
|
//The task's "infinite" inner loop is entered.
|
||||||
while (1) {
|
while (1) {
|
||||||
for (ObjectList::iterator it = objectList.begin();
|
for (auto const &object: objectList) {
|
||||||
it != objectList.end(); ++it) {
|
object->performOperation();
|
||||||
(*it)->performOperation();
|
|
||||||
}
|
}
|
||||||
if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
|
|
||||||
|
if(not PosixThread::delayUntil(&lastWakeTime, periodMs)){
|
||||||
char name[20] = {0};
|
char name[20] = {0};
|
||||||
int status = pthread_getname_np(pthread_self(),name,sizeof(name));
|
int status = pthread_getname_np(pthread_self(), name, sizeof(name));
|
||||||
if(status==0){
|
if(status == 0) {
|
||||||
sif::error << "PeriodicPosixTask " << name << ": Deadline "
|
sif::error << "PeriodicPosixTask " << name << ": Deadline "
|
||||||
"missed." << std::endl;
|
"missed." << std::endl;
|
||||||
}else{
|
}
|
||||||
|
else {
|
||||||
sif::error << "PeriodicPosixTask X: Deadline missed. " <<
|
sif::error << "PeriodicPosixTask X: Deadline missed. " <<
|
||||||
status << std::endl;
|
status << std::endl;
|
||||||
}
|
}
|
||||||
if (this->deadlineMissedFunc != NULL) {
|
if (this->deadlineMissedFunc != nullptr) {
|
||||||
this->deadlineMissedFunc();
|
this->deadlineMissedFunc();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -32,7 +32,7 @@ public:
|
|||||||
* The address of the task object is passed as an argument
|
* The address of the task object is passed as an argument
|
||||||
* to the system call.
|
* to the system call.
|
||||||
*/
|
*/
|
||||||
ReturnValue_t startTask(void);
|
ReturnValue_t startTask() override;
|
||||||
/**
|
/**
|
||||||
* Adds an object to the list of objects to be executed.
|
* Adds an object to the list of objects to be executed.
|
||||||
* The objects are executed in the order added.
|
* The objects are executed in the order added.
|
||||||
|
@ -64,6 +64,7 @@ enum {
|
|||||||
LOCAL_POOL_OWNER_IF, //LPIF 58
|
LOCAL_POOL_OWNER_IF, //LPIF 58
|
||||||
POOL_VARIABLE_IF, //PVA 59
|
POOL_VARIABLE_IF, //PVA 59
|
||||||
HOUSEKEEPING_MANAGER, //HKM 60
|
HOUSEKEEPING_MANAGER, //HKM 60
|
||||||
|
DLE_ENCODER, //DLEE 61
|
||||||
FW_CLASS_ID_COUNT //is actually count + 1 !
|
FW_CLASS_ID_COUNT //is actually count + 1 !
|
||||||
|
|
||||||
};
|
};
|
||||||
|
@ -1,5 +1,5 @@
|
|||||||
#ifndef ENDIANSWAPPER_H_
|
#ifndef FSFW_SERIALIZE_ENDIANCONVERTER_H_
|
||||||
#define ENDIANSWAPPER_H_
|
#define FSFW_SERIALIZE_ENDIANCONVERTER_H_
|
||||||
|
|
||||||
#include "../osal/Endiness.h"
|
#include "../osal/Endiness.h"
|
||||||
#include <cstring>
|
#include <cstring>
|
||||||
@ -35,9 +35,7 @@
|
|||||||
*/
|
*/
|
||||||
class EndianConverter {
|
class EndianConverter {
|
||||||
private:
|
private:
|
||||||
EndianConverter() {
|
EndianConverter() {};
|
||||||
}
|
|
||||||
;
|
|
||||||
public:
|
public:
|
||||||
/**
|
/**
|
||||||
* Convert a typed variable between big endian and machine endian.
|
* Convert a typed variable between big endian and machine endian.
|
||||||
@ -123,4 +121,4 @@ public:
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* ENDIANSWAPPER_H_ */
|
#endif /* FSFW_SERIALIZE_ENDIANCONVERTER_H_ */
|
||||||
|
@ -1,13 +1,14 @@
|
|||||||
#ifndef FRAMEWORK_SERIALIZE_SERIALARRAYLISTADAPTER_H_
|
#ifndef FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_
|
||||||
#define FRAMEWORK_SERIALIZE_SERIALARRAYLISTADAPTER_H_
|
#define FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_
|
||||||
|
|
||||||
#include "../container/ArrayList.h"
|
|
||||||
#include "SerializeIF.h"
|
#include "SerializeIF.h"
|
||||||
|
#include "../container/ArrayList.h"
|
||||||
#include <utility>
|
#include <utility>
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
* Also serializes length field !
|
||||||
|
* @author baetz
|
||||||
* @ingroup serialize
|
* @ingroup serialize
|
||||||
* @author baetz
|
|
||||||
*/
|
*/
|
||||||
template<typename T, typename count_t = uint8_t>
|
template<typename T, typename count_t = uint8_t>
|
||||||
class SerialArrayListAdapter : public SerializeIF {
|
class SerialArrayListAdapter : public SerializeIF {
|
||||||
@ -21,14 +22,14 @@ public:
|
|||||||
}
|
}
|
||||||
|
|
||||||
static ReturnValue_t serialize(const ArrayList<T, count_t>* list,
|
static ReturnValue_t serialize(const ArrayList<T, count_t>* list,
|
||||||
uint8_t** buffer, size_t* size, size_t maxSize,
|
uint8_t** buffer, size_t* size, size_t maxSize,
|
||||||
Endianness streamEndianness) {
|
Endianness streamEndianness) {
|
||||||
ReturnValue_t result = SerializeAdapter::serialize(&list->size,
|
ReturnValue_t result = SerializeAdapter::serialize(&list->size,
|
||||||
buffer, size, maxSize, streamEndianness);
|
buffer, size, maxSize, streamEndianness);
|
||||||
count_t i = 0;
|
count_t i = 0;
|
||||||
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
|
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
|
||||||
result = SerializeAdapter::serialize(&list->entries[i], buffer,
|
result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
|
||||||
size, maxSize, streamEndianness);
|
maxSize, streamEndianness);
|
||||||
++i;
|
++i;
|
||||||
}
|
}
|
||||||
return result;
|
return result;
|
||||||
@ -55,17 +56,18 @@ public:
|
|||||||
}
|
}
|
||||||
|
|
||||||
static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
|
static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
|
||||||
const uint8_t** buffer, size_t* size,
|
const uint8_t** buffer, size_t* size,
|
||||||
Endianness streamEndianness) {
|
Endianness streamEndianness) {
|
||||||
count_t tempSize = 0;
|
count_t tempSize = 0;
|
||||||
ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
|
ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
|
||||||
buffer, size, streamEndianness);
|
buffer, size, streamEndianness);
|
||||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
if (tempSize > list->maxSize()) {
|
if (tempSize > list->maxSize()) {
|
||||||
return SerializeIF::TOO_MANY_ELEMENTS;
|
return SerializeIF::TOO_MANY_ELEMENTS;
|
||||||
}
|
}
|
||||||
|
|
||||||
list->size = tempSize;
|
list->size = tempSize;
|
||||||
count_t i = 0;
|
count_t i = 0;
|
||||||
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
|
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
|
||||||
@ -76,10 +78,9 @@ public:
|
|||||||
}
|
}
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
private:
|
private:
|
||||||
ArrayList<T, count_t> *adaptee;
|
ArrayList<T, count_t> *adaptee;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
#endif /* FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_ */
|
||||||
|
|
||||||
#endif /* FRAMEWORK_SERIALIZE_SERIALARRAYLISTADAPTER_H_ */
|
|
||||||
|
@ -1,31 +1,57 @@
|
|||||||
#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
|
#ifndef FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_
|
||||||
#define SERIALFIXEDARRAYLISTADAPTER_H_
|
#define FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_
|
||||||
|
|
||||||
#include "../container/FixedArrayList.h"
|
|
||||||
#include "SerialArrayListAdapter.h"
|
#include "SerialArrayListAdapter.h"
|
||||||
|
#include "../container/FixedArrayList.h"
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* \ingroup serialize
|
* @brief This adapter provides an interface for SerializeIF to serialize and
|
||||||
|
* deserialize buffers with a header containing the buffer length.
|
||||||
|
* @details
|
||||||
|
* Can be used by SerialLinkedListAdapter by declaring
|
||||||
|
* as a linked element with SerializeElement<SerialFixedArrayListAdapter<...>>.
|
||||||
|
* The sequence of objects is defined in the constructor by
|
||||||
|
* using the setStart and setNext functions.
|
||||||
|
*
|
||||||
|
* @tparam BUFFER_TYPE: Specifies the data type of the buffer
|
||||||
|
* @tparam MAX_SIZE: Specifies the maximum allowed number of elements
|
||||||
|
* (not bytes!)
|
||||||
|
* @tparam count_t: specifies the type/size of the length field which defaults
|
||||||
|
* to one byte.
|
||||||
|
* @ingroup serialize
|
||||||
*/
|
*/
|
||||||
template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
|
template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
|
||||||
class SerialFixedArrayListAdapter : public FixedArrayList<T, MAX_SIZE, count_t>, public SerializeIF {
|
class SerialFixedArrayListAdapter :
|
||||||
|
public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>,
|
||||||
|
public SerializeIF {
|
||||||
public:
|
public:
|
||||||
|
/**
|
||||||
|
* Constructor arguments are forwarded to FixedArrayList constructor.
|
||||||
|
* Refer to the fixed array list constructors for different options.
|
||||||
|
* @param args
|
||||||
|
*/
|
||||||
template<typename... Args>
|
template<typename... Args>
|
||||||
SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
|
SerialFixedArrayListAdapter(Args... args) :
|
||||||
}
|
FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(
|
||||||
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
|
std::forward<Args>(args)...){}
|
||||||
size_t maxSize, Endianness streamEndianness) const {
|
|
||||||
return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, maxSize, streamEndianness);
|
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
|
||||||
}
|
size_t maxSize, Endianness streamEndianness) const {
|
||||||
size_t getSerializedSize() const {
|
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
|
||||||
return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
|
buffer, size, maxSize, streamEndianness);
|
||||||
}
|
}
|
||||||
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
|
||||||
Endianness streamEndianness) {
|
size_t getSerializedSize() const {
|
||||||
return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, streamEndianness);
|
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
|
||||||
}
|
getSerializedSize(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
||||||
|
Endianness streamEndianness) {
|
||||||
|
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
|
||||||
|
buffer, size, streamEndianness);
|
||||||
|
}
|
||||||
|
|
||||||
};
|
};
|
||||||
|
|
||||||
|
#endif /* FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_ */
|
||||||
|
|
||||||
#endif /* SERIALFIXEDARRAYLISTADAPTER_H_ */
|
|
||||||
|
@ -1,32 +1,52 @@
|
|||||||
/**
|
#ifndef FSFW_SERIALIZE_SERIALLINKEDLISTADAPTER_H_
|
||||||
* @file SerialLinkedListAdapter.h
|
#define FSFW_SERIALIZE_SERIALLINKEDLISTADAPTER_H_
|
||||||
* @brief This file defines the SerialLinkedListAdapter class.
|
|
||||||
* @date 22.07.2014
|
|
||||||
* @author baetz
|
|
||||||
*/
|
|
||||||
#ifndef SERIALLINKEDLISTADAPTER_H_
|
|
||||||
#define SERIALLINKEDLISTADAPTER_H_
|
|
||||||
|
|
||||||
#include "../container/SinglyLinkedList.h"
|
#include "../container/SinglyLinkedList.h"
|
||||||
#include "SerializeAdapter.h"
|
#include "SerializeAdapter.h"
|
||||||
#include "SerializeElement.h"
|
#include "SerializeElement.h"
|
||||||
#include "SerializeIF.h"
|
#include "SerializeIF.h"
|
||||||
//This is where we need the SerializeAdapter!
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* \ingroup serialize
|
* @brief Implement the conversion of object data to data streams
|
||||||
|
* or vice-versa, using linked lists.
|
||||||
|
* @details
|
||||||
|
* An alternative to the AutoSerializeAdapter functions
|
||||||
|
* - All object members with a datatype are declared as
|
||||||
|
* SerializeElement<element_type> members inside the class
|
||||||
|
* implementing this adapter.
|
||||||
|
* - The element type can also be a SerialBufferAdapter to
|
||||||
|
* de-/serialize buffers.
|
||||||
|
* - The element type can also be a SerialFixedArrayListAdapter to
|
||||||
|
* de-/serialize buffers with a size header, which is scanned automatically.
|
||||||
|
*
|
||||||
|
* The sequence of objects is defined in the constructor by using
|
||||||
|
* the setStart and setNext functions.
|
||||||
|
*
|
||||||
|
* 1. The serialization process is done by instantiating the class and
|
||||||
|
* calling serialize after all SerializeElement entries have been set by
|
||||||
|
* using the constructor or setter functions. An additional size variable
|
||||||
|
* can be supplied which is calculated/incremented automatically.
|
||||||
|
* 2. The deserialization process is done by instantiating the class and
|
||||||
|
* supplying a buffer with the data which is converted into an object.
|
||||||
|
* The size of data to serialize can be supplied and is
|
||||||
|
* decremented in the function. Range checking is done internally.
|
||||||
|
* @author baetz
|
||||||
|
* @ingroup serialize
|
||||||
*/
|
*/
|
||||||
template<typename T, typename count_t = uint8_t>
|
template<typename T, typename count_t = uint8_t>
|
||||||
class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
|
class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
|
||||||
public:
|
public:
|
||||||
|
|
||||||
SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
|
SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
|
||||||
bool printCount = false) :
|
bool printCount = false) :
|
||||||
SinglyLinkedList<T>(start), printCount(printCount) {
|
SinglyLinkedList<T>(start), printCount(printCount) {
|
||||||
}
|
}
|
||||||
|
|
||||||
SerialLinkedListAdapter(LinkedElement<T>* first, bool printCount = false) :
|
SerialLinkedListAdapter(LinkedElement<T>* first, bool printCount = false) :
|
||||||
SinglyLinkedList<T>(first), printCount(printCount) {
|
SinglyLinkedList<T>(first), printCount(printCount) {
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
SerialLinkedListAdapter(bool printCount = false) :
|
SerialLinkedListAdapter(bool printCount = false) :
|
||||||
SinglyLinkedList<T>(), printCount(printCount) {
|
SinglyLinkedList<T>(), printCount(printCount) {
|
||||||
}
|
}
|
||||||
@ -49,13 +69,14 @@ public:
|
|||||||
uint8_t** buffer, size_t* size, size_t maxSize,
|
uint8_t** buffer, size_t* size, size_t maxSize,
|
||||||
Endianness streamEndianness) {
|
Endianness streamEndianness) {
|
||||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||||
while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
|
while ((result == HasReturnvaluesIF::RETURN_OK) and (element != nullptr)) {
|
||||||
result = element->value->serialize(buffer, size, maxSize,
|
result = element->value->serialize(buffer, size, maxSize,
|
||||||
streamEndianness);
|
streamEndianness);
|
||||||
element = element->getNext();
|
element = element->getNext();
|
||||||
}
|
}
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
virtual size_t getSerializedSize() const override {
|
virtual size_t getSerializedSize() const override {
|
||||||
if (printCount) {
|
if (printCount) {
|
||||||
return SerialLinkedListAdapter<T>::getSerializedSize()
|
return SerialLinkedListAdapter<T>::getSerializedSize()
|
||||||
@ -64,32 +85,44 @@ public:
|
|||||||
return getSerializedSize(SinglyLinkedList<T>::start);
|
return getSerializedSize(SinglyLinkedList<T>::start);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static size_t getSerializedSize(const LinkedElement<T> *element) {
|
static size_t getSerializedSize(const LinkedElement<T> *element) {
|
||||||
size_t size = 0;
|
size_t size = 0;
|
||||||
while (element != NULL) {
|
while (element != nullptr) {
|
||||||
size += element->value->getSerializedSize();
|
size += element->value->getSerializedSize();
|
||||||
element = element->getNext();
|
element = element->getNext();
|
||||||
}
|
}
|
||||||
return size;
|
return size;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
||||||
Endianness streamEndianness) override {
|
Endianness streamEndianness) override {
|
||||||
return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
|
return deSerialize(SinglyLinkedList<T>::start, buffer, size,
|
||||||
|
streamEndianness);
|
||||||
}
|
}
|
||||||
|
|
||||||
static ReturnValue_t deSerialize(LinkedElement<T>* element,
|
static ReturnValue_t deSerialize(LinkedElement<T>* element,
|
||||||
const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
|
const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
|
||||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||||
while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
|
while ((result == HasReturnvaluesIF::RETURN_OK) and (element != nullptr)) {
|
||||||
result = element->value->deSerialize(buffer, size, streamEndianness);
|
result = element->value->deSerialize(buffer, size, streamEndianness);
|
||||||
element = element->getNext();
|
element = element->getNext();
|
||||||
}
|
}
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
bool printCount;
|
/**
|
||||||
|
* Copying is forbidden by deleting the copy constructor and the copy
|
||||||
|
* assignment operator because of the pointers to the linked list members.
|
||||||
|
* Unless the child class implements an own copy constructor or
|
||||||
|
* copy assignment operator, these operation will throw a compiler error.
|
||||||
|
* @param
|
||||||
|
*/
|
||||||
|
SerialLinkedListAdapter(const SerialLinkedListAdapter &) = delete;
|
||||||
|
SerialLinkedListAdapter& operator=(const SerialLinkedListAdapter&) = delete;
|
||||||
|
|
||||||
|
bool printCount;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* SERIALLINKEDLISTADAPTER_H_ */
|
#endif /* FSFW_SERIALIZE_SERIALLINKEDLISTADAPTER_H_ */
|
||||||
|
@ -7,17 +7,26 @@
|
|||||||
#include <cstddef>
|
#include <cstddef>
|
||||||
#include <type_traits>
|
#include <type_traits>
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* \ingroup serialize
|
* @brief These adapters provides an interface to use the SerializeIF functions
|
||||||
|
* with arbitrary template objects to facilitate and simplify the
|
||||||
|
* serialization of classes with different multiple different data types
|
||||||
|
* into buffers and vice-versa.
|
||||||
|
* @details
|
||||||
|
* The correct serialization or deserialization function is chosen at
|
||||||
|
* compile time with template type deduction.
|
||||||
|
*
|
||||||
|
* @ingroup serialize
|
||||||
*/
|
*/
|
||||||
|
|
||||||
class SerializeAdapter {
|
class SerializeAdapter {
|
||||||
public:
|
public:
|
||||||
/***
|
/***
|
||||||
* This function can be used to serialize a trivial copy-able type or a child of SerializeIF.
|
* This function can be used to serialize a trivial copy-able type or a
|
||||||
|
* child of SerializeIF.
|
||||||
* The right template to be called is determined in the function itself.
|
* The right template to be called is determined in the function itself.
|
||||||
* For objects of non trivial copy-able type this function is almost never called by the user directly.
|
* For objects of non trivial copy-able type this function is almost never
|
||||||
* Instead helpers for specific types like SerialArrayListAdapter or SerialLinkedListAdapter is the right choice here.
|
* called by the user directly. Instead helpers for specific types like
|
||||||
|
* SerialArrayListAdapter or SerialLinkedListAdapter is the right choice here.
|
||||||
*
|
*
|
||||||
* @param[in] object Object to serialize, the used type is deduced from this pointer
|
* @param[in] object Object to serialize, the used type is deduced from this pointer
|
||||||
* @param[in/out] buffer Buffer to serialize into. Will be moved by the function.
|
* @param[in/out] buffer Buffer to serialize into. Will be moved by the function.
|
||||||
@ -86,7 +95,8 @@ private:
|
|||||||
template<typename T>
|
template<typename T>
|
||||||
class InternalSerializeAdapter<T, false> {
|
class InternalSerializeAdapter<T, false> {
|
||||||
static_assert (std::is_trivially_copyable<T>::value,
|
static_assert (std::is_trivially_copyable<T>::value,
|
||||||
"If a type needs to be serialized it must be a child of SerializeIF or trivially copy-able");
|
"If a type needs to be serialized it must be a child of "
|
||||||
|
"SerializeIF or trivially copy-able");
|
||||||
public:
|
public:
|
||||||
static ReturnValue_t serialize(const T *object, uint8_t **buffer,
|
static ReturnValue_t serialize(const T *object, uint8_t **buffer,
|
||||||
size_t *size, size_t max_size,
|
size_t *size, size_t max_size,
|
||||||
@ -95,7 +105,8 @@ private:
|
|||||||
if (size == nullptr) {
|
if (size == nullptr) {
|
||||||
size = &ignoredSize;
|
size = &ignoredSize;
|
||||||
}
|
}
|
||||||
//Check remaining size is large enough and check integer overflow of *size
|
// Check remaining size is large enough and check integer
|
||||||
|
// overflow of *size
|
||||||
size_t newSize = sizeof(T) + *size;
|
size_t newSize = sizeof(T) + *size;
|
||||||
if ((newSize <= max_size) and (newSize > *size)) {
|
if ((newSize <= max_size) and (newSize > *size)) {
|
||||||
T tmp;
|
T tmp;
|
||||||
@ -111,7 +122,7 @@ private:
|
|||||||
tmp = *object;
|
tmp = *object;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
memcpy(*buffer, &tmp, sizeof(T));
|
std::memcpy(*buffer, &tmp, sizeof(T));
|
||||||
*size += sizeof(T);
|
*size += sizeof(T);
|
||||||
(*buffer) += sizeof(T);
|
(*buffer) += sizeof(T);
|
||||||
return HasReturnvaluesIF::RETURN_OK;
|
return HasReturnvaluesIF::RETURN_OK;
|
||||||
@ -125,7 +136,7 @@ private:
|
|||||||
T tmp;
|
T tmp;
|
||||||
if (*size >= sizeof(T)) {
|
if (*size >= sizeof(T)) {
|
||||||
*size -= sizeof(T);
|
*size -= sizeof(T);
|
||||||
memcpy(&tmp, *buffer, sizeof(T));
|
std::memcpy(&tmp, *buffer, sizeof(T));
|
||||||
switch (streamEndianness) {
|
switch (streamEndianness) {
|
||||||
case SerializeIF::Endianness::BIG:
|
case SerializeIF::Endianness::BIG:
|
||||||
*object = EndianConverter::convertBigEndian<T>(tmp);
|
*object = EndianConverter::convertBigEndian<T>(tmp);
|
||||||
|
@ -1,12 +1,20 @@
|
|||||||
#ifndef SERIALIZEELEMENT_H_
|
#ifndef FSFW_SERIALIZE_SERIALIZEELEMENT_H_
|
||||||
#define SERIALIZEELEMENT_H_
|
#define FSFW_SERIALIZE_SERIALIZEELEMENT_H_
|
||||||
|
|
||||||
#include "../container/SinglyLinkedList.h"
|
|
||||||
#include "SerializeAdapter.h"
|
#include "SerializeAdapter.h"
|
||||||
|
#include "../container/SinglyLinkedList.h"
|
||||||
#include <utility>
|
#include <utility>
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* \ingroup serialize
|
* @brief This class is used to mark datatypes for serialization with the
|
||||||
|
* SerialLinkedListAdapter
|
||||||
|
* @details
|
||||||
|
* Used by declaring any arbitrary datatype with SerializeElement<T> myVariable,
|
||||||
|
* inside a SerialLinkedListAdapter implementation and setting the sequence
|
||||||
|
* of objects with setNext() and setStart().
|
||||||
|
* Serialization and Deserialization is then performed automatically in
|
||||||
|
* specified sequence order.
|
||||||
|
* @ingroup serialize
|
||||||
*/
|
*/
|
||||||
template<typename T>
|
template<typename T>
|
||||||
class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
|
class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
|
||||||
@ -19,7 +27,7 @@ public:
|
|||||||
SerializeElement() :
|
SerializeElement() :
|
||||||
LinkedElement<SerializeIF>(this) {
|
LinkedElement<SerializeIF>(this) {
|
||||||
}
|
}
|
||||||
T entry;
|
|
||||||
ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
|
ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
|
||||||
Endianness streamEndianness) const override {
|
Endianness streamEndianness) const override {
|
||||||
return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
|
return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
|
||||||
@ -35,6 +43,7 @@ public:
|
|||||||
return SerializeAdapter::deSerialize(&entry, buffer, size,
|
return SerializeAdapter::deSerialize(&entry, buffer, size,
|
||||||
streamEndianness);
|
streamEndianness);
|
||||||
}
|
}
|
||||||
|
|
||||||
operator T() {
|
operator T() {
|
||||||
return entry;
|
return entry;
|
||||||
}
|
}
|
||||||
@ -43,9 +52,12 @@ public:
|
|||||||
entry = newValue;
|
entry = newValue;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
T* operator->() {
|
T* operator->() {
|
||||||
return &entry;
|
return &entry;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
T entry;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* SERIALIZEELEMENT_H_ */
|
#endif /* FSFW_SERIALIZE_SERIALIZEELEMENT_H_ */
|
||||||
|
@ -2,7 +2,7 @@
|
|||||||
#define FSFW_SERIALIZE_SERIALIZEIF_H_
|
#define FSFW_SERIALIZE_SERIALIZEIF_H_
|
||||||
|
|
||||||
#include "../returnvalues/HasReturnvaluesIF.h"
|
#include "../returnvalues/HasReturnvaluesIF.h"
|
||||||
#include <stddef.h>
|
#include <cstddef>
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* @defgroup serialize Serialization
|
* @defgroup serialize Serialization
|
||||||
@ -10,7 +10,10 @@
|
|||||||
*/
|
*/
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Translation of objects into data streams and from data streams.
|
* @brief Translation of objects into data streams and from data streams.
|
||||||
|
* @details
|
||||||
|
* Also provides options to convert from/to data with different endianness.
|
||||||
|
* variables.
|
||||||
* @ingroup serialize
|
* @ingroup serialize
|
||||||
*/
|
*/
|
||||||
class SerializeIF {
|
class SerializeIF {
|
||||||
|
@ -1,7 +1,8 @@
|
|||||||
#include "CCSDSTime.h"
|
#include "../timemanager/CCSDSTime.h"
|
||||||
#include <stdio.h>
|
#include <cstdio>
|
||||||
#include <inttypes.h>
|
#include <cinttypes>
|
||||||
#include <math.h>
|
#include <cmath>
|
||||||
|
|
||||||
|
|
||||||
CCSDSTime::CCSDSTime() {
|
CCSDSTime::CCSDSTime() {
|
||||||
}
|
}
|
||||||
|
@ -5,7 +5,7 @@
|
|||||||
|
|
||||||
#include "Clock.h"
|
#include "Clock.h"
|
||||||
#include "../returnvalues/HasReturnvaluesIF.h"
|
#include "../returnvalues/HasReturnvaluesIF.h"
|
||||||
#include <stdint.h>
|
#include <cstdint>
|
||||||
|
|
||||||
bool operator<(const timeval& lhs, const timeval& rhs);
|
bool operator<(const timeval& lhs, const timeval& rhs);
|
||||||
bool operator<=(const timeval& lhs, const timeval& rhs);
|
bool operator<=(const timeval& lhs, const timeval& rhs);
|
||||||
|
Loading…
Reference in New Issue
Block a user