Merge pull request 'TMTC Stack Refactoring' (#106) from mueller/tmtc-stack-refactoring into develop

Reviewed-on: #106
This commit is contained in:
Robin Müller 2022-08-16 17:30:16 +02:00
commit 42c5881c50
287 changed files with 7165 additions and 4659 deletions

View File

@ -8,10 +8,19 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
# [unreleased] # [unreleased]
# [v6.0.0]
## Added ## Added
- Add new `UnsignedByteField` class - Add new `UnsignedByteField` class
## Changes
- Overhaul of the TMTC stack, including various changes and improvements
for other modules
PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/655
which also includes a migration guide
# [v5.0.0] 25.07.2022 # [v5.0.0] 25.07.2022
## Changes ## Changes

View File

@ -1,6 +1,6 @@
pipeline { pipeline {
environment { environment {
BUILDDIR = 'build-tests' BUILDDIR = 'cmake-build-tests'
} }
agent { agent {
docker { image 'fsfw-ci:d3'} docker { image 'fsfw-ci:d3'}

View File

@ -36,7 +36,7 @@ void Factory::produceFsfwObjects(void) {
void Factory::setStaticFrameworkObjectIds() { void Factory::setStaticFrameworkObjectIds() {
PusServiceBase::packetSource = objects::NO_OBJECT; PusServiceBase::packetSource = objects::NO_OBJECT;
PusServiceBase::packetDestination = objects::NO_OBJECT; PusServiceBase::PACKET_DESTINATION = objects::NO_OBJECT;
CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT; CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT; CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;

View File

@ -13,7 +13,7 @@ from shutil import which
from typing import List from typing import List
UNITTEST_FOLDER_NAME = "build-tests" UNITTEST_FOLDER_NAME = "cmake-build-tests"
DOCS_FOLDER_NAME = "build-docs" DOCS_FOLDER_NAME = "build-docs"

View File

@ -1,17 +0,0 @@
#include "CFDPMessage.h"
CFDPMessage::CFDPMessage() {}
CFDPMessage::~CFDPMessage() {}
void CFDPMessage::setCommand(CommandMessage *message, store_address_t cfdpPacket) {
message->setParameter(cfdpPacket.raw);
}
store_address_t CFDPMessage::getStoreId(const CommandMessage *message) {
store_address_t storeAddressCFDPPacket;
storeAddressCFDPPacket = message->getParameter();
return storeAddressCFDPPacket;
}
void CFDPMessage::clear(CommandMessage *message) {}

View File

@ -1,4 +1,4 @@
target_sources(${LIB_FSFW_NAME} PRIVATE CFDPHandler.cpp CFDPMessage.cpp) target_sources(${LIB_FSFW_NAME} PRIVATE CfdpHandler.cpp CfdpMessage.cpp)
add_subdirectory(pdu) add_subdirectory(pdu)
add_subdirectory(tlv) add_subdirectory(tlv)

View File

@ -1,16 +1,16 @@
#include "fsfw/cfdp/CFDPHandler.h" #include "fsfw/cfdp/CfdpHandler.h"
#include "fsfw/cfdp/CFDPMessage.h" #include "fsfw/cfdp/CfdpMessage.h"
#include "fsfw/ipc/CommandMessage.h" #include "fsfw/ipc/CommandMessage.h"
#include "fsfw/ipc/QueueFactory.h" #include "fsfw/ipc/QueueFactory.h"
#include "fsfw/objectmanager/ObjectManager.h" #include "fsfw/objectmanager/ObjectManager.h"
#include "fsfw/storagemanager/storeAddress.h" #include "fsfw/storagemanager/storeAddress.h"
#include "fsfw/tmtcservices/AcceptsTelemetryIF.h" #include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
object_id_t CFDPHandler::packetSource = 0; object_id_t CfdpHandler::packetSource = 0;
object_id_t CFDPHandler::packetDestination = 0; object_id_t CfdpHandler::packetDestination = 0;
CFDPHandler::CFDPHandler(object_id_t setObjectId, CFDPDistributor* dist) CfdpHandler::CfdpHandler(object_id_t setObjectId, CFDPDistributor* dist)
: SystemObject(setObjectId) { : SystemObject(setObjectId) {
auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this)); auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
requestQueue = QueueFactory::instance()->createMessageQueue( requestQueue = QueueFactory::instance()->createMessageQueue(
@ -18,9 +18,9 @@ CFDPHandler::CFDPHandler(object_id_t setObjectId, CFDPDistributor* dist)
distributor = dist; distributor = dist;
} }
CFDPHandler::~CFDPHandler() {} CfdpHandler::~CfdpHandler() = default;
ReturnValue_t CFDPHandler::initialize() { ReturnValue_t CfdpHandler::initialize() {
ReturnValue_t result = SystemObject::initialize(); ReturnValue_t result = SystemObject::initialize();
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
@ -29,7 +29,7 @@ ReturnValue_t CFDPHandler::initialize() {
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t CFDPHandler::handleRequest(store_address_t storeId) { ReturnValue_t CfdpHandler::handleRequest(store_address_t storeId) {
#if FSFW_VERBOSE_LEVEL >= 1 #if FSFW_VERBOSE_LEVEL >= 1
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::debug << "CFDPHandler::handleRequest" << std::endl; sif::debug << "CFDPHandler::handleRequest" << std::endl;
@ -43,17 +43,17 @@ ReturnValue_t CFDPHandler::handleRequest(store_address_t storeId) {
return RETURN_OK; return RETURN_OK;
} }
ReturnValue_t CFDPHandler::performOperation(uint8_t opCode) { ReturnValue_t CfdpHandler::performOperation(uint8_t opCode) {
ReturnValue_t status = RETURN_OK; ReturnValue_t status = RETURN_OK;
CommandMessage currentMessage; CommandMessage currentMessage;
for (status = this->requestQueue->receiveMessage(&currentMessage); status == RETURN_OK; for (status = this->requestQueue->receiveMessage(&currentMessage); status == RETURN_OK;
status = this->requestQueue->receiveMessage(&currentMessage)) { status = this->requestQueue->receiveMessage(&currentMessage)) {
store_address_t storeId = CFDPMessage::getStoreId(&currentMessage); store_address_t storeId = CfdpMessage::getStoreId(&currentMessage);
this->handleRequest(storeId); this->handleRequest(storeId);
} }
return RETURN_OK; return RETURN_OK;
} }
uint16_t CFDPHandler::getIdentifier() { return 0; } uint16_t CfdpHandler::getIdentifier() { return 0; }
MessageQueueId_t CFDPHandler::getRequestQueue() { return this->requestQueue->getId(); } MessageQueueId_t CfdpHandler::getRequestQueue() { return this->requestQueue->getId(); }

View File

@ -12,18 +12,18 @@ namespace Factory {
void setStaticFrameworkObjectIds(); void setStaticFrameworkObjectIds();
} }
class CFDPHandler : public ExecutableObjectIF, class CfdpHandler : public ExecutableObjectIF,
public AcceptsTelecommandsIF, public AcceptsTelecommandsIF,
public SystemObject, public SystemObject,
public HasReturnvaluesIF { public HasReturnvaluesIF {
friend void(Factory::setStaticFrameworkObjectIds)(); friend void(Factory::setStaticFrameworkObjectIds)();
public: public:
CFDPHandler(object_id_t setObjectId, CFDPDistributor* distributor); CfdpHandler(object_id_t setObjectId, CFDPDistributor* distributor);
/** /**
* The destructor is empty. * The destructor is empty.
*/ */
virtual ~CFDPHandler(); virtual ~CfdpHandler();
virtual ReturnValue_t handleRequest(store_address_t storeId); virtual ReturnValue_t handleRequest(store_address_t storeId);
@ -45,7 +45,7 @@ class CFDPHandler : public ExecutableObjectIF,
* The current CFDP packet to be processed. * The current CFDP packet to be processed.
* It is deleted after handleRequest was executed. * It is deleted after handleRequest was executed.
*/ */
CFDPPacketStored currentPacket; CfdpPacketStored currentPacket;
static object_id_t packetSource; static object_id_t packetSource;

View File

@ -0,0 +1,17 @@
#include "CfdpMessage.h"
CfdpMessage::CfdpMessage() = default;
CfdpMessage::~CfdpMessage() = default;
void CfdpMessage::setCommand(CommandMessage *message, store_address_t cfdpPacket) {
message->setParameter(cfdpPacket.raw);
}
store_address_t CfdpMessage::getStoreId(const CommandMessage *message) {
store_address_t storeId;
storeId = static_cast<store_address_t>(message->getParameter());
return storeId;
}
void CfdpMessage::clear(CommandMessage *message) {}

View File

@ -5,14 +5,14 @@
#include "fsfw/objectmanager/ObjectManagerIF.h" #include "fsfw/objectmanager/ObjectManagerIF.h"
#include "fsfw/storagemanager/StorageManagerIF.h" #include "fsfw/storagemanager/StorageManagerIF.h"
class CFDPMessage { class CfdpMessage {
private: private:
CFDPMessage(); CfdpMessage();
public: public:
static const uint8_t MESSAGE_ID = messagetypes::CFDP; static const uint8_t MESSAGE_ID = messagetypes::CFDP;
virtual ~CFDPMessage(); virtual ~CfdpMessage();
static void setCommand(CommandMessage* message, store_address_t cfdpPacket); static void setCommand(CommandMessage* message, store_address_t cfdpPacket);
static store_address_t getStoreId(const CommandMessage* message); static store_address_t getStoreId(const CommandMessage* message);

View File

@ -15,28 +15,21 @@ static constexpr uint8_t VERSION_BITS = 0b00100000;
static constexpr uint8_t CFDP_CLASS_ID = CLASS_ID::CFDP; static constexpr uint8_t CFDP_CLASS_ID = CLASS_ID::CFDP;
static constexpr ReturnValue_t INVALID_TLV_TYPE = static constexpr ReturnValue_t INVALID_TLV_TYPE = result::makeCode(CFDP_CLASS_ID, 1);
HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 1); static constexpr ReturnValue_t INVALID_DIRECTIVE_FIELDS = result::makeCode(CFDP_CLASS_ID, 2);
static constexpr ReturnValue_t INVALID_DIRECTIVE_FIELDS = static constexpr ReturnValue_t INVALID_PDU_DATAFIELD_LEN = result::makeCode(CFDP_CLASS_ID, 3);
HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 2); static constexpr ReturnValue_t INVALID_ACK_DIRECTIVE_FIELDS = result::makeCode(CFDP_CLASS_ID, 4);
static constexpr ReturnValue_t INVALID_PDU_DATAFIELD_LEN =
HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 3);
static constexpr ReturnValue_t INVALID_ACK_DIRECTIVE_FIELDS =
HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 4);
//! Can not parse options. This can also occur because there are options //! Can not parse options. This can also occur because there are options
//! available but the user did not pass a valid options array //! available but the user did not pass a valid options array
static constexpr ReturnValue_t METADATA_CANT_PARSE_OPTIONS = static constexpr ReturnValue_t METADATA_CANT_PARSE_OPTIONS = result::makeCode(CFDP_CLASS_ID, 5);
HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 5); static constexpr ReturnValue_t NAK_CANT_PARSE_OPTIONS = result::makeCode(CFDP_CLASS_ID, 6);
static constexpr ReturnValue_t NAK_CANT_PARSE_OPTIONS =
HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 6);
static constexpr ReturnValue_t FINISHED_CANT_PARSE_FS_RESPONSES = static constexpr ReturnValue_t FINISHED_CANT_PARSE_FS_RESPONSES =
HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 6); result::makeCode(CFDP_CLASS_ID, 6);
static constexpr ReturnValue_t FILESTORE_REQUIRES_SECOND_FILE = static constexpr ReturnValue_t FILESTORE_REQUIRES_SECOND_FILE = result::makeCode(CFDP_CLASS_ID, 8);
HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 8);
//! Can not parse filestore response because user did not pass a valid instance //! Can not parse filestore response because user did not pass a valid instance
//! or remaining size is invalid //! or remaining size is invalid
static constexpr ReturnValue_t FILESTORE_RESPONSE_CANT_PARSE_FS_MESSAGE = static constexpr ReturnValue_t FILESTORE_RESPONSE_CANT_PARSE_FS_MESSAGE =
HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 9); result::makeCode(CFDP_CLASS_ID, 9);
//! Checksum types according to the SANA Checksum Types registry //! Checksum types according to the SANA Checksum Types registry
//! https://sanaregistry.org/r/checksum_identifiers/ //! https://sanaregistry.org/r/checksum_identifiers/

View File

@ -6,7 +6,7 @@
#include "fsfw/objectmanager/ObjectManager.h" #include "fsfw/objectmanager/ObjectManager.h"
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/storagemanager/StorageManagerIF.h" #include "fsfw/storagemanager/StorageManagerIF.h"
#include "fsfw/tmtcpacket/SpacePacketBase.h" #include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h" #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
#include "fsfw/tmtcservices/TmTcMessage.h" #include "fsfw/tmtcservices/TmTcMessage.h"

View File

@ -79,8 +79,7 @@ class HasLocalDataPoolIF {
* @param clearMessage If this is set to true, the pool manager will take care of * @param clearMessage If this is set to true, the pool manager will take care of
* clearing the store automatically * clearing the store automatically
*/ */
virtual void handleChangedDataset(sid_t sid, virtual void handleChangedDataset(sid_t sid, store_address_t storeId = store_address_t::invalid(),
store_address_t storeId = storeId::INVALID_STORE_ADDRESS,
bool* clearMessage = nullptr) { bool* clearMessage = nullptr) {
if (clearMessage != nullptr) { if (clearMessage != nullptr) {
*clearMessage = true; *clearMessage = true;
@ -100,7 +99,7 @@ class HasLocalDataPoolIF {
* after the callback. * after the callback.
*/ */
virtual void handleChangedPoolVariable(gp_id_t gpid, virtual void handleChangedPoolVariable(gp_id_t gpid,
store_address_t storeId = storeId::INVALID_STORE_ADDRESS, store_address_t storeId = store_address_t::invalid(),
bool* clearMessage = nullptr) { bool* clearMessage = nullptr) {
if (clearMessage != nullptr) { if (clearMessage != nullptr) {
*clearMessage = true; *clearMessage = true;

View File

@ -1,6 +1,5 @@
#include "fsfw/datapoollocal/LocalDataPoolManager.h" #include "fsfw/datapoollocal/LocalDataPoolManager.h"
#include <array>
#include <cmath> #include <cmath>
#include "fsfw/datapoollocal.h" #include "fsfw/datapoollocal.h"
@ -15,6 +14,7 @@
#include "internal/HasLocalDpIFManagerAttorney.h" #include "internal/HasLocalDpIFManagerAttorney.h"
#include "internal/LocalPoolDataSetAttorney.h" #include "internal/LocalPoolDataSetAttorney.h"
// TODO: Get rid of this. This should be a constructor argument, not something hardcoded in any way
object_id_t LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING; object_id_t LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING;
LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse, LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
@ -57,7 +57,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
} }
if (defaultHkDestination != objects::NO_OBJECT) { if (defaultHkDestination != objects::NO_OBJECT) {
AcceptsHkPacketsIF* hkPacketReceiver = auto* hkPacketReceiver =
ObjectManager::instance()->get<AcceptsHkPacketsIF>(defaultHkDestination); ObjectManager::instance()->get<AcceptsHkPacketsIF>(defaultHkDestination);
if (hkPacketReceiver != nullptr) { if (hkPacketReceiver != nullptr) {
hkDestinationId = hkPacketReceiver->getHkQueue(); hkDestinationId = hkPacketReceiver->getHkQueue();
@ -209,9 +209,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
} }
/* Prepare and send update snapshot */ /* Prepare and send update snapshot */
timeval now; timeval now{};
Clock::getClock_timeval(&now); Clock::getClock_timeval(&now);
CCSDSTime::CDS_short cds; CCSDSTime::CDS_short cds{};
CCSDSTime::convertToCcsds(&cds, &now); CCSDSTime::convertToCcsds(&cds, &now);
HousekeepingSnapshot updatePacket( HousekeepingSnapshot updatePacket(
reinterpret_cast<uint8_t*>(&cds), sizeof(cds), reinterpret_cast<uint8_t*>(&cds), sizeof(cds),
@ -245,9 +245,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
} }
/* Prepare and send update snapshot */ /* Prepare and send update snapshot */
timeval now; timeval now{};
Clock::getClock_timeval(&now); Clock::getClock_timeval(&now);
CCSDSTime::CDS_short cds; CCSDSTime::CDS_short cds{};
CCSDSTime::convertToCcsds(&cds, &now); CCSDSTime::convertToCcsds(&cds, &now);
HousekeepingSnapshot updatePacket( HousekeepingSnapshot updatePacket(
reinterpret_cast<uint8_t*>(&cds), sizeof(cds), reinterpret_cast<uint8_t*>(&cds), sizeof(cds),
@ -291,12 +291,7 @@ ReturnValue_t LocalDataPoolManager::addUpdateToStore(HousekeepingSnapshot& updat
void LocalDataPoolManager::handleChangeResetLogic(DataType type, DataId dataId, void LocalDataPoolManager::handleChangeResetLogic(DataType type, DataId dataId,
MarkChangedIF* toReset) { MarkChangedIF* toReset) {
if (hkUpdateResetList == nullptr) { for (auto& changeInfo : hkUpdateResetList) {
/* Config error */
return;
}
HkUpdateResetList& listRef = *hkUpdateResetList;
for (auto& changeInfo : listRef) {
if (changeInfo.dataType != type) { if (changeInfo.dataType != type) {
continue; continue;
} }
@ -326,38 +321,37 @@ void LocalDataPoolManager::handleChangeResetLogic(DataType type, DataId dataId,
} }
void LocalDataPoolManager::resetHkUpdateResetHelper() { void LocalDataPoolManager::resetHkUpdateResetHelper() {
if (hkUpdateResetList == nullptr) { for (auto& changeInfo : hkUpdateResetList) {
return;
}
for (auto& changeInfo : *hkUpdateResetList) {
changeInfo.currentUpdateCounter = changeInfo.updateCounter; changeInfo.currentUpdateCounter = changeInfo.updateCounter;
} }
} }
ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, bool enableReporting, ReturnValue_t LocalDataPoolManager::subscribeForRegularPeriodicPacket(
float collectionInterval, subdp::RegularHkPeriodicParams params) {
bool isDiagnostics, return subscribeForPeriodicPacket(params);
object_id_t packetDestination) { }
AcceptsHkPacketsIF* hkReceiverObject =
ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
if (hkReceiverObject == nullptr) {
printWarningOrError(sif::OutputTypes::OUT_WARNING, "subscribeForPeriodicPacket",
QUEUE_OR_DESTINATION_INVALID);
return QUEUE_OR_DESTINATION_INVALID;
}
ReturnValue_t LocalDataPoolManager::subscribeForDiagPeriodicPacket(
subdp::DiagnosticsHkPeriodicParams params) {
return subscribeForPeriodicPacket(params);
}
ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(subdp::ParamsBase& params) {
struct HkReceiver hkReceiver; struct HkReceiver hkReceiver;
hkReceiver.dataId.sid = sid; hkReceiver.dataId.sid = params.sid;
hkReceiver.reportingType = ReportingType::PERIODIC; hkReceiver.reportingType = ReportingType::PERIODIC;
hkReceiver.dataType = DataType::DATA_SET; hkReceiver.dataType = DataType::DATA_SET;
hkReceiver.destinationQueue = hkReceiverObject->getHkQueue(); if (params.receiver == MessageQueueIF::NO_QUEUE) {
hkReceiver.destinationQueue = hkDestinationId;
} else {
hkReceiver.destinationQueue = params.receiver;
}
LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid); LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, params.sid);
if (dataSet != nullptr) { if (dataSet != nullptr) {
LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enableReporting); LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, params.enableReporting);
LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics); LocalPoolDataSetAttorney::setDiagnostic(*dataSet, params.isDiagnostics());
LocalPoolDataSetAttorney::initializePeriodicHelper(*dataSet, collectionInterval, LocalPoolDataSetAttorney::initializePeriodicHelper(*dataSet, params.collectionInterval,
owner->getPeriodicOperationFrequency()); owner->getPeriodicOperationFrequency());
} }
@ -365,27 +359,30 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, bool e
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(sid_t sid, bool isDiagnostics, ReturnValue_t LocalDataPoolManager::subscribeForRegularUpdatePacket(
bool reportingEnabled, subdp::RegularHkUpdateParams params) {
object_id_t packetDestination) { return subscribeForUpdatePacket(params);
AcceptsHkPacketsIF* hkReceiverObject = }
ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination); ReturnValue_t LocalDataPoolManager::subscribeForDiagUpdatePacket(
if (hkReceiverObject == nullptr) { subdp::DiagnosticsHkUpdateParams params) {
printWarningOrError(sif::OutputTypes::OUT_WARNING, "subscribeForPeriodicPacket", return subscribeForUpdatePacket(params);
QUEUE_OR_DESTINATION_INVALID); }
return QUEUE_OR_DESTINATION_INVALID;
}
ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(subdp::ParamsBase& params) {
struct HkReceiver hkReceiver; struct HkReceiver hkReceiver;
hkReceiver.dataId.sid = sid; hkReceiver.dataId.sid = params.sid;
hkReceiver.reportingType = ReportingType::UPDATE_HK; hkReceiver.reportingType = ReportingType::UPDATE_HK;
hkReceiver.dataType = DataType::DATA_SET; hkReceiver.dataType = DataType::DATA_SET;
hkReceiver.destinationQueue = hkReceiverObject->getHkQueue(); if (params.receiver == MessageQueueIF::NO_QUEUE) {
hkReceiver.destinationQueue = hkDestinationId;
} else {
hkReceiver.destinationQueue = params.receiver;
}
LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid); LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, params.sid);
if (dataSet != nullptr) { if (dataSet != nullptr) {
LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, true); LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, true);
LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics); LocalPoolDataSetAttorney::setDiagnostic(*dataSet, params.isDiagnostics());
} }
hkReceivers.push_back(hkReceiver); hkReceivers.push_back(hkReceiver);
@ -436,11 +433,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessage(
} }
void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType, DataId dataId) { void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType, DataId dataId) {
if (hkUpdateResetList == nullptr) { for (auto& updateResetStruct : hkUpdateResetList) {
hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
}
for (auto& updateResetStruct : *hkUpdateResetList) {
if (dataType == DataType::DATA_SET) { if (dataType == DataType::DATA_SET) {
if (updateResetStruct.dataId.sid == dataId.sid) { if (updateResetStruct.dataId.sid == dataId.sid) {
updateResetStruct.updateCounter++; updateResetStruct.updateCounter++;
@ -464,7 +457,7 @@ void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType, D
} else { } else {
hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId; hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
} }
hkUpdateResetList->push_back(hkUpdateResetHelper); hkUpdateResetList.push_back(hkUpdateResetHelper);
} }
ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* message) { ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* message) {
@ -643,6 +636,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
/* Error, all destinations invalid */ /* Error, all destinations invalid */
printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket", printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
QUEUE_OR_DESTINATION_INVALID); QUEUE_OR_DESTINATION_INVALID);
return QUEUE_OR_DESTINATION_INVALID;
} }
destination = hkDestinationId; destination = hkDestinationId;
} }
@ -821,9 +815,7 @@ void LocalDataPoolManager::clearReceiversList() {
/* Clear the vector completely and releases allocated memory. */ /* Clear the vector completely and releases allocated memory. */
HkReceivers().swap(hkReceivers); HkReceivers().swap(hkReceivers);
/* Also clear the reset helper if it exists */ /* Also clear the reset helper if it exists */
if (hkUpdateResetList != nullptr) { HkUpdateResetList().swap(hkUpdateResetList);
HkUpdateResetList().swap(*hkUpdateResetList);
}
} }
MutexIF* LocalDataPoolManager::getLocalPoolMutex() { return this->mutex; } MutexIF* LocalDataPoolManager::getLocalPoolMutex() { return this->mutex; }
@ -885,3 +877,7 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
} }
LocalDataPoolManager* LocalDataPoolManager::getPoolManagerHandle() { return this; } LocalDataPoolManager* LocalDataPoolManager::getPoolManagerHandle() { return this; }
void LocalDataPoolManager::setHkDestinationId(MessageQueueId_t hkDestId) {
hkDestinationId = hkDestId;
}

View File

@ -8,6 +8,7 @@
#include "ProvidesDataPoolSubscriptionIF.h" #include "ProvidesDataPoolSubscriptionIF.h"
#include "fsfw/datapool/DataSetIF.h" #include "fsfw/datapool/DataSetIF.h"
#include "fsfw/datapool/PoolEntry.h" #include "fsfw/datapool/PoolEntry.h"
#include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
#include "fsfw/housekeeping/HousekeepingMessage.h" #include "fsfw/housekeeping/HousekeepingMessage.h"
#include "fsfw/housekeeping/HousekeepingPacketDownlink.h" #include "fsfw/housekeeping/HousekeepingPacketDownlink.h"
#include "fsfw/housekeeping/PeriodicHousekeepingHelper.h" #include "fsfw/housekeeping/PeriodicHousekeepingHelper.h"
@ -80,7 +81,9 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
*/ */
LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse, LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
bool appendValidityBuffer = true); bool appendValidityBuffer = true);
virtual ~LocalDataPoolManager(); ~LocalDataPoolManager() override;
void setHkDestinationId(MessageQueueId_t hkDestId);
/** /**
* Assigns the queue to use. Make sure to call this in the #initialize * Assigns the queue to use. Make sure to call this in the #initialize
@ -112,31 +115,6 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
*/ */
virtual ReturnValue_t performHkOperation(); virtual ReturnValue_t performHkOperation();
/**
* @brief Subscribe for the generation of periodic packets.
* @details
* This subscription mechanism will generally be used by the data creator
* to generate housekeeping packets which are downlinked directly.
* @return
*/
ReturnValue_t subscribeForPeriodicPacket(
sid_t sid, bool enableReporting, float collectionInterval, bool isDiagnostics,
object_id_t packetDestination = defaultHkDestination) override;
/**
* @brief Subscribe for the generation of packets if the dataset
* is marked as changed.
* @details
* This subscription mechanism will generally be used by the data creator.
* @param sid
* @param isDiagnostics
* @param packetDestination
* @return
*/
ReturnValue_t subscribeForUpdatePacket(
sid_t sid, bool reportingEnabled, bool isDiagnostics,
object_id_t packetDestination = defaultHkDestination) override;
/** /**
* @brief Subscribe for a notification message which will be sent * @brief Subscribe for a notification message which will be sent
* if a dataset has changed. * if a dataset has changed.
@ -151,7 +129,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
* Otherwise, only an notification message is sent. * Otherwise, only an notification message is sent.
* @return * @return
*/ */
ReturnValue_t subscribeForSetUpdateMessage(const uint32_t setId, object_id_t destinationObject, ReturnValue_t subscribeForSetUpdateMessage(uint32_t setId, object_id_t destinationObject,
MessageQueueId_t targetQueueId, MessageQueueId_t targetQueueId,
bool generateSnapshot) override; bool generateSnapshot) override;
@ -169,7 +147,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
* Otherwise, only an notification message is sent. * Otherwise, only an notification message is sent.
* @return * @return
*/ */
ReturnValue_t subscribeForVariableUpdateMessage(const lp_id_t localPoolId, ReturnValue_t subscribeForVariableUpdateMessage(lp_id_t localPoolId,
object_id_t destinationObject, object_id_t destinationObject,
MessageQueueId_t targetQueueId, MessageQueueId_t targetQueueId,
bool generateSnapshot) override; bool generateSnapshot) override;
@ -252,7 +230,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
*/ */
void clearReceiversList(); void clearReceiversList();
object_id_t getCreatorObjectId() const; [[nodiscard]] object_id_t getCreatorObjectId() const;
/** /**
* Get the pointer to the mutex. Can be used to lock the data pool * Get the pointer to the mutex. Can be used to lock the data pool
@ -262,9 +240,17 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
*/ */
MutexIF* getMutexHandle(); MutexIF* getMutexHandle();
virtual LocalDataPoolManager* getPoolManagerHandle() override; LocalDataPoolManager* getPoolManagerHandle() override;
ReturnValue_t subscribeForRegularPeriodicPacket(subdp::RegularHkPeriodicParams params) override;
ReturnValue_t subscribeForDiagPeriodicPacket(subdp::DiagnosticsHkPeriodicParams params) override;
ReturnValue_t subscribeForRegularUpdatePacket(subdp::RegularHkUpdateParams params) override;
ReturnValue_t subscribeForDiagUpdatePacket(subdp::DiagnosticsHkUpdateParams params) override;
protected: protected:
ReturnValue_t subscribeForPeriodicPacket(subdp::ParamsBase& params);
ReturnValue_t subscribeForUpdatePacket(subdp::ParamsBase& params);
/** Core data structure for the actual pool data */ /** Core data structure for the actual pool data */
localpool::DataPool localPoolMap; localpool::DataPool localPoolMap;
/** Every housekeeping data manager has a mutex to protect access /** Every housekeeping data manager has a mutex to protect access
@ -312,8 +298,8 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
using HkUpdateResetList = std::vector<struct HkUpdateResetHelper>; using HkUpdateResetList = std::vector<struct HkUpdateResetHelper>;
/** This list is used to manage creating multiple update packets and only resetting /** This list is used to manage creating multiple update packets and only resetting
the update flag if all of them were created. Will only be created when needed. */ the update flag if all of them were created. */
HkUpdateResetList* hkUpdateResetList = nullptr; HkUpdateResetList hkUpdateResetList = HkUpdateResetList();
/** This is the map holding the actual data. Should only be initialized /** This is the map holding the actual data. Should only be initialized
* once ! */ * once ! */

View File

@ -1,24 +1,90 @@
#ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_ #ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
#define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_ #define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
#include "../ipc/messageQueueDefinitions.h" #include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
#include "../returnvalues/HasReturnvaluesIF.h" #include "fsfw/ipc/MessageQueueIF.h"
#include "fsfw/ipc/messageQueueDefinitions.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
#include "localPoolDefinitions.h" #include "localPoolDefinitions.h"
namespace subdp {
struct ParamsBase {
ParamsBase(sid_t sid, bool enableReporting, float collectionInterval, bool diagnostics)
: sid(sid),
enableReporting(enableReporting),
collectionInterval(collectionInterval),
diagnostics(diagnostics) {}
[[nodiscard]] bool isDiagnostics() const { return diagnostics; }
sid_t sid;
bool enableReporting;
float collectionInterval;
MessageQueueId_t receiver = MessageQueueIF::NO_QUEUE;
protected:
bool diagnostics;
};
struct RegularHkPeriodicParams : public ParamsBase {
RegularHkPeriodicParams(sid_t sid, bool enableReporting, float collectionInterval)
: ParamsBase(sid, enableReporting, collectionInterval, false) {}
};
struct DiagnosticsHkPeriodicParams : public ParamsBase {
DiagnosticsHkPeriodicParams(sid_t sid, bool enableReporting, float collectionInterval)
: ParamsBase(sid, enableReporting, collectionInterval, true) {}
};
struct RegularHkUpdateParams : public ParamsBase {
RegularHkUpdateParams(sid_t sid, bool enableReporting)
: ParamsBase(sid, enableReporting, 0.0, false) {}
};
struct DiagnosticsHkUpdateParams : public ParamsBase {
DiagnosticsHkUpdateParams(sid_t sid, bool enableReporting)
: ParamsBase(sid, enableReporting, 0.0, true) {}
};
} // namespace subdp
class ProvidesDataPoolSubscriptionIF { class ProvidesDataPoolSubscriptionIF {
public: public:
virtual ~ProvidesDataPoolSubscriptionIF(){}; virtual ~ProvidesDataPoolSubscriptionIF() = default;
/** /**
* @brief Subscribe for the generation of periodic packets. * @brief Subscribe for the generation of periodic packets. Used for regular HK packets
* @details * @details
* This subscription mechanism will generally be used by the data creator * This subscription mechanism will generally be used by the data creator
* to generate housekeeping packets which are downlinked directly. * to generate housekeeping packets which are downlinked directly.
* @return * @return
*/ */
virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting, virtual ReturnValue_t subscribeForRegularPeriodicPacket(
float collectionInterval, bool isDiagnostics, subdp::RegularHkPeriodicParams params) = 0;
object_id_t packetDestination) = 0; /**
* @brief Subscribe for the generation of periodic packets. Used for diagnostic packets
* @details
* This subscription mechanism will generally be used by the data creator
* to generate housekeeping packets which are downlinked directly.
* @return
*/
virtual ReturnValue_t subscribeForDiagPeriodicPacket(
subdp::DiagnosticsHkPeriodicParams params) = 0;
[[deprecated(
"Please use the new API which takes all arguments as one wrapper "
"struct")]] virtual ReturnValue_t
subscribeForPeriodicPacket(sid_t sid, bool enableReporting, float collectionInterval,
bool isDiagnostics,
object_id_t packetDestination = objects::NO_OBJECT) {
if (isDiagnostics) {
subdp::DiagnosticsHkPeriodicParams params(sid, enableReporting, collectionInterval);
return subscribeForDiagPeriodicPacket(params);
} else {
subdp::RegularHkPeriodicParams params(sid, enableReporting, collectionInterval);
return subscribeForRegularPeriodicPacket(params);
}
}
/** /**
* @brief Subscribe for the generation of packets if the dataset * @brief Subscribe for the generation of packets if the dataset
* is marked as changed. * is marked as changed.
@ -29,9 +95,28 @@ class ProvidesDataPoolSubscriptionIF {
* @param packetDestination * @param packetDestination
* @return * @return
*/ */
virtual ReturnValue_t subscribeForUpdatePacket(sid_t sid, bool reportingEnabled, virtual ReturnValue_t subscribeForRegularUpdatePacket(subdp::RegularHkUpdateParams params) = 0;
bool isDiagnostics, virtual ReturnValue_t subscribeForDiagUpdatePacket(subdp::DiagnosticsHkUpdateParams params) = 0;
object_id_t packetDestination) = 0;
// virtual ReturnValue_t
// subscribeForUpdatePacket(sid_t sid, bool reportingEnabled, bool isDiagnostics) {
// return subscribeForUpdatePacket(sid, reportingEnabled, isDiagnostics, objects::NO_OBJECT);
// }
[[deprecated(
"Please use the new API which takes all arguments as one wrapper "
"struct")]] virtual ReturnValue_t
subscribeForUpdatePacket(sid_t sid, bool reportingEnabled, bool isDiagnostics,
object_id_t packetDestination = objects::NO_OBJECT) {
if (isDiagnostics) {
subdp::DiagnosticsHkUpdateParams params(sid, reportingEnabled);
return subscribeForDiagUpdatePacket(params);
} else {
subdp::RegularHkUpdateParams params(sid, reportingEnabled);
return subscribeForRegularUpdatePacket(params);
}
}
/** /**
* @brief Subscribe for a notification message which will be sent * @brief Subscribe for a notification message which will be sent
* if a dataset has changed. * if a dataset has changed.
@ -46,8 +131,7 @@ class ProvidesDataPoolSubscriptionIF {
* Otherwise, only an notification message is sent. * Otherwise, only an notification message is sent.
* @return * @return
*/ */
virtual ReturnValue_t subscribeForSetUpdateMessage(const uint32_t setId, virtual ReturnValue_t subscribeForSetUpdateMessage(uint32_t setId, object_id_t destinationObject,
object_id_t destinationObject,
MessageQueueId_t targetQueueId, MessageQueueId_t targetQueueId,
bool generateSnapshot) = 0; bool generateSnapshot) = 0;
/** /**
@ -64,7 +148,7 @@ class ProvidesDataPoolSubscriptionIF {
* only an notification message is sent. * only an notification message is sent.
* @return * @return
*/ */
virtual ReturnValue_t subscribeForVariableUpdateMessage(const lp_id_t localPoolId, virtual ReturnValue_t subscribeForVariableUpdateMessage(lp_id_t localPoolId,
object_id_t destinationObject, object_id_t destinationObject,
MessageQueueId_t targetQueueId, MessageQueueId_t targetQueueId,
bool generateSnapshot) = 0; bool generateSnapshot) = 0;

View File

@ -9,8 +9,8 @@
class HealthTable : public HealthTableIF, public SystemObject { class HealthTable : public HealthTableIF, public SystemObject {
public: public:
HealthTable(object_id_t objectid); explicit HealthTable(object_id_t objectid);
virtual ~HealthTable(); ~HealthTable() override;
void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs); void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);

View File

@ -1,12 +1,12 @@
#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ #ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ #define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
#include "../ipc/MessageQueueMessageIF.h" #include "fsfw/ipc/MessageQueueMessageIF.h"
class AcceptsHkPacketsIF { class AcceptsHkPacketsIF {
public: public:
virtual ~AcceptsHkPacketsIF(){}; virtual ~AcceptsHkPacketsIF() = default;
virtual MessageQueueId_t getHkQueue() const = 0; [[nodiscard]] virtual MessageQueueId_t getHkQueue() const = 0;
}; };
#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */ #endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */

View File

@ -127,11 +127,12 @@ MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
ReturnValue_t InternalErrorReporter::initializeLocalDataPool(localpool::DataPool &localDataPoolMap, ReturnValue_t InternalErrorReporter::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
LocalDataPoolManager &poolManager) { LocalDataPoolManager &poolManager) {
localDataPoolMap.emplace(errorPoolIds::TM_HITS, new PoolEntry<uint32_t>()); localDataPoolMap.emplace(errorPoolIds::TM_HITS, &tmHitsEntry);
localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS, new PoolEntry<uint32_t>()); localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS, &queueHitsEntry);
localDataPoolMap.emplace(errorPoolIds::STORE_HITS, new PoolEntry<uint32_t>()); localDataPoolMap.emplace(errorPoolIds::STORE_HITS, &storeHitsEntry);
poolManager.subscribeForPeriodicPacket(internalErrorSid, false, getPeriodicOperationFrequency(), poolManager.subscribeForDiagPeriodicPacket(subdp::DiagnosticsHkPeriodicParams(
true); internalErrorSid, false,
static_cast<float>(getPeriodicOperationFrequency()) / static_cast<float>(1000.0)));
internalErrorDataset.setValidity(true, true); internalErrorDataset.setValidity(true, true);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }

View File

@ -72,6 +72,9 @@ class InternalErrorReporter : public SystemObject,
uint32_t queueHits = 0; uint32_t queueHits = 0;
uint32_t tmHits = 0; uint32_t tmHits = 0;
uint32_t storeHits = 0; uint32_t storeHits = 0;
PoolEntry<uint32_t> tmHitsEntry = PoolEntry<uint32_t>();
PoolEntry<uint32_t> storeHitsEntry = PoolEntry<uint32_t>();
PoolEntry<uint32_t> queueHitsEntry = PoolEntry<uint32_t>();
uint32_t getAndResetQueueHits(); uint32_t getAndResetQueueHits();
void incrementQueueHits(); void incrementQueueHits();

View File

@ -12,7 +12,7 @@
*/ */
class InternalErrorReporterIF { class InternalErrorReporterIF {
public: public:
virtual ~InternalErrorReporterIF() {} virtual ~InternalErrorReporterIF() = default;
/** /**
* @brief Function to be called if a message queue could not be sent. * @brief Function to be called if a message queue could not be sent.
* @details OSAL Implementations should call this function to indicate that * @details OSAL Implementations should call this function to indicate that

View File

@ -8,7 +8,7 @@ MessageQueueBase::MessageQueueBase(MessageQueueId_t id, MessageQueueId_t default
} }
} }
MessageQueueBase::~MessageQueueBase() {} MessageQueueBase::~MessageQueueBase() = default;
ReturnValue_t MessageQueueBase::sendToDefault(MessageQueueMessageIF* message) { ReturnValue_t MessageQueueBase::sendToDefault(MessageQueueMessageIF* message) {
return sendToDefaultFrom(message, this->getId(), false); return sendToDefaultFrom(message, this->getId(), false);

View File

@ -7,28 +7,28 @@
class MessageQueueBase : public MessageQueueIF { class MessageQueueBase : public MessageQueueIF {
public: public:
MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest, MqArgs* mqArgs); MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest, MqArgs* mqArgs);
virtual ~MessageQueueBase(); ~MessageQueueBase() override;
// Default implementations for MessageQueueIF where possible // Default implementations for MessageQueueIF where possible
virtual MessageQueueId_t getLastPartner() const override; [[nodiscard]] MessageQueueId_t getLastPartner() const override;
virtual MessageQueueId_t getId() const override; [[nodiscard]] MessageQueueId_t getId() const override;
virtual MqArgs& getMqArgs() override; MqArgs& getMqArgs() override;
virtual void setDefaultDestination(MessageQueueId_t defaultDestination) override; void setDefaultDestination(MessageQueueId_t defaultDestination) override;
virtual MessageQueueId_t getDefaultDestination() const override; [[nodiscard]] MessageQueueId_t getDefaultDestination() const override;
virtual bool isDefaultDestinationSet() const override; [[nodiscard]] bool isDefaultDestinationSet() const override;
virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message, ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
bool ignoreFault) override; bool ignoreFault) override;
virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override; ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
virtual ReturnValue_t reply(MessageQueueMessageIF* message) override; ReturnValue_t reply(MessageQueueMessageIF* message) override;
virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message, ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
MessageQueueId_t* receivedFrom) override; MessageQueueId_t* receivedFrom) override;
virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom, ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
bool ignoreFault = false) override; bool ignoreFault = false) override;
// OSAL specific, forward the abstract function // OSAL specific, forward the abstract function
virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0; ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override = 0;
virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message, ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
MessageQueueId_t sentFrom, bool ignoreFault = false) = 0; MessageQueueId_t sentFrom, bool ignoreFault = false) override = 0;
protected: protected:
MessageQueueId_t id = MessageQueueIF::NO_QUEUE; MessageQueueId_t id = MessageQueueIF::NO_QUEUE;

View File

@ -30,7 +30,7 @@ class MessageQueueIF {
//! [EXPORT] : [COMMENT] Returned if the target destination is invalid. //! [EXPORT] : [COMMENT] Returned if the target destination is invalid.
static constexpr ReturnValue_t DESTINATION_INVALID = MAKE_RETURN_CODE(4); static constexpr ReturnValue_t DESTINATION_INVALID = MAKE_RETURN_CODE(4);
virtual ~MessageQueueIF() {} virtual ~MessageQueueIF() = default;
/** /**
* @brief This operation sends a message to the last communication partner. * @brief This operation sends a message to the last communication partner.
* @details * @details
@ -82,11 +82,11 @@ class MessageQueueIF {
/** /**
* @brief This method returns the message queue ID of the last communication partner. * @brief This method returns the message queue ID of the last communication partner.
*/ */
virtual MessageQueueId_t getLastPartner() const = 0; [[nodiscard]] virtual MessageQueueId_t getLastPartner() const = 0;
/** /**
* @brief This method returns the message queue ID of this class's message queue. * @brief This method returns the message queue ID of this class's message queue.
*/ */
virtual MessageQueueId_t getId() const = 0; [[nodiscard]] virtual MessageQueueId_t getId() const = 0;
/** /**
* @brief With the sendMessage call, a queue message is sent to a receiving queue. * @brief With the sendMessage call, a queue message is sent to a receiving queue.
@ -159,9 +159,9 @@ class MessageQueueIF {
/** /**
* @brief This method is a simple getter for the default destination. * @brief This method is a simple getter for the default destination.
*/ */
virtual MessageQueueId_t getDefaultDestination() const = 0; [[nodiscard]] virtual MessageQueueId_t getDefaultDestination() const = 0;
virtual bool isDefaultDestinationSet() const = 0; [[nodiscard]] virtual bool isDefaultDestinationSet() const = 0;
virtual MqArgs& getMqArgs() = 0; virtual MqArgs& getMqArgs() = 0;
}; };

View File

@ -10,10 +10,10 @@ MessageQueueMessage::MessageQueueMessage() : messageSize(getMinimumMessageSize()
} }
MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size)
: messageSize(this->HEADER_SIZE + size) { : messageSize(MessageQueueMessage::HEADER_SIZE + size) {
if (size <= this->MAX_DATA_SIZE) { if (size <= MessageQueueMessage::MAX_DATA_SIZE) {
memcpy(this->getData(), data, size); std::memcpy(internalBuffer + MessageQueueMessage::HEADER_SIZE, data, size);
this->messageSize = this->HEADER_SIZE + size; this->messageSize = MessageQueueMessage::HEADER_SIZE + size;
} else { } else {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "MessageQueueMessage: Passed size larger than maximum" sif::warning << "MessageQueueMessage: Passed size larger than maximum"
@ -21,21 +21,23 @@ MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size)
<< std::endl; << std::endl;
#endif #endif
memset(this->internalBuffer, 0, sizeof(this->internalBuffer)); memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
this->messageSize = this->HEADER_SIZE; this->messageSize = MessageQueueMessage::HEADER_SIZE;
} }
} }
MessageQueueMessage::~MessageQueueMessage() {} MessageQueueMessage::~MessageQueueMessage() = default;
const uint8_t* MessageQueueMessage::getBuffer() const { return this->internalBuffer; } const uint8_t* MessageQueueMessage::getBuffer() const { return this->internalBuffer; }
uint8_t* MessageQueueMessage::getBuffer() { return this->internalBuffer; } uint8_t* MessageQueueMessage::getBuffer() { return this->internalBuffer; }
const uint8_t* MessageQueueMessage::getData() const { const uint8_t* MessageQueueMessage::getData() const {
return this->internalBuffer + this->HEADER_SIZE; return this->internalBuffer + MessageQueueMessage::HEADER_SIZE;
} }
uint8_t* MessageQueueMessage::getData() { return this->internalBuffer + this->HEADER_SIZE; } uint8_t* MessageQueueMessage::getData() {
return this->internalBuffer + MessageQueueMessage::HEADER_SIZE;
}
MessageQueueId_t MessageQueueMessage::getSender() const { MessageQueueId_t MessageQueueMessage::getSender() const {
MessageQueueId_t temp_id; MessageQueueId_t temp_id;
@ -58,14 +60,22 @@ void MessageQueueMessage::print(bool printWholeMessage) {
} }
} }
void MessageQueueMessage::clear() { memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE); } void MessageQueueMessage::clear() {
memset(this->getBuffer(), 0, MessageQueueMessage::MAX_MESSAGE_SIZE);
}
size_t MessageQueueMessage::getMessageSize() const { return this->messageSize; } size_t MessageQueueMessage::getMessageSize() const { return this->messageSize; }
void MessageQueueMessage::setMessageSize(size_t messageSize) { this->messageSize = messageSize; } void MessageQueueMessage::setMessageSize(size_t messageSize_) { this->messageSize = messageSize_; }
size_t MessageQueueMessage::getMinimumMessageSize() const { return this->MIN_MESSAGE_SIZE; } size_t MessageQueueMessage::getMinimumMessageSize() const {
return MessageQueueMessage::MIN_MESSAGE_SIZE;
}
size_t MessageQueueMessage::getMaximumMessageSize() const { return this->MAX_MESSAGE_SIZE; } size_t MessageQueueMessage::getMaximumMessageSize() const {
return MessageQueueMessage::MAX_MESSAGE_SIZE;
}
size_t MessageQueueMessage::getMaximumDataSize() const { return this->MAX_DATA_SIZE; } size_t MessageQueueMessage::getMaximumDataSize() const {
return MessageQueueMessage::MAX_DATA_SIZE;
}

View File

@ -25,6 +25,30 @@
*/ */
class MessageQueueMessage : public MessageQueueMessageIF { class MessageQueueMessage : public MessageQueueMessageIF {
public: public:
/**
* @brief This constant defines the maximum size of the data content,
* excluding the header.
* @details
* It may be changed if necessary, but in general should be kept
* as small as possible.
*/
static const size_t MAX_DATA_SIZE = 24;
/**
* @brief This constant defines the maximum total size in bytes
* of a sent message.
* @details
* It is the sum of the maximum data and the header size. Be aware that
* this constant is used to define the buffer sizes for every message
* queue in the system. So, a change here may have significant impact on
* the required resources.
*/
static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
/**
* @brief Defines the minimum size of a message where only the
* header is included
*/
static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
/** /**
* @brief The class is initialized empty with this constructor. * @brief The class is initialized empty with this constructor.
* @details * @details
@ -50,59 +74,12 @@ class MessageQueueMessage : public MessageQueueMessageIF {
* @brief As no memory is allocated in this class, * @brief As no memory is allocated in this class,
* the destructor is empty. * the destructor is empty.
*/ */
virtual ~MessageQueueMessage(); ~MessageQueueMessage() override;
/**
* @brief The size information of each message is stored in
* this attribute.
* @details
* It is public to simplify usage and to allow for passing the size
* address as a pointer. Care must be taken when inheriting from this class,
* as every child class is responsible for managing the size information by
* itself. When using the class to receive a message, the size information
* is updated automatically.
*
* Please note that the minimum size is limited by the size of the header
* while the maximum size is limited by the maximum allowed message size.
*/
size_t messageSize;
/**
* @brief This constant defines the maximum size of the data content,
* excluding the header.
* @details
* It may be changed if necessary, but in general should be kept
* as small as possible.
*/
static const size_t MAX_DATA_SIZE = 24;
/**
* @brief This constant defines the maximum total size in bytes
* of a sent message.
* @details
* It is the sum of the maximum data and the header size. Be aware that
* this constant is used to define the buffer sizes for every message
* queue in the system. So, a change here may have significant impact on
* the required resources.
*/
static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
/**
* @brief Defines the minimum size of a message where only the
* header is included
*/
static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
private:
/**
* @brief This is the internal buffer that contains the
* actual message data.
*/
uint8_t internalBuffer[MAX_MESSAGE_SIZE];
public:
/** /**
* @brief This method is used to get the complete data of the message. * @brief This method is used to get the complete data of the message.
*/ */
const uint8_t* getBuffer() const override; [[nodiscard]] const uint8_t* getBuffer() const override;
/** /**
* @brief This method is used to get the complete data of the message. * @brief This method is used to get the complete data of the message.
*/ */
@ -112,7 +89,7 @@ class MessageQueueMessage : public MessageQueueMessageIF {
* @details * @details
* It shall be used by child classes to add data at the right position. * It shall be used by child classes to add data at the right position.
*/ */
const uint8_t* getData() const override; [[nodiscard]] const uint8_t* getData() const override;
/** /**
* @brief This method is used to fetch the data content of the message. * @brief This method is used to fetch the data content of the message.
* @details * @details
@ -123,7 +100,7 @@ class MessageQueueMessage : public MessageQueueMessageIF {
* @brief This method is used to extract the sender's message * @brief This method is used to extract the sender's message
* queue id information from a received message. * queue id information from a received message.
*/ */
MessageQueueId_t getSender() const override; [[nodiscard]] MessageQueueId_t getSender() const override;
/** /**
* @brief With this method, the whole content * @brief With this method, the whole content
* and the message size is set to zero. * and the message size is set to zero.
@ -138,16 +115,40 @@ class MessageQueueMessage : public MessageQueueMessageIF {
*/ */
void setSender(MessageQueueId_t setId) override; void setSender(MessageQueueId_t setId) override;
virtual size_t getMessageSize() const override; [[nodiscard]] size_t getMessageSize() const override;
virtual void setMessageSize(size_t messageSize) override; void setMessageSize(size_t messageSize) override;
virtual size_t getMinimumMessageSize() const override; [[nodiscard]] size_t getMinimumMessageSize() const override;
virtual size_t getMaximumMessageSize() const override; [[nodiscard]] size_t getMaximumMessageSize() const override;
virtual size_t getMaximumDataSize() const override; [[nodiscard]] size_t getMaximumDataSize() const override;
/** /**
* @brief This is a debug method that prints the content. * @brief This is a debug method that prints the content.
*/ */
void print(bool printWholeMessage); void print(bool printWholeMessage);
/**
* TODO: This really should not be public. If it should be possible to pass size address as a
* pointer, add a getter function returning a const reference to the size
* @brief The size information of each message is stored in
* this attribute.
* @details
* It is public to simplify usage and to allow for passing the size
* address as a pointer. Care must be taken when inheriting from this class,
* as every child class is responsible for managing the size information by
* itself. When using the class to receive a message, the size information
* is updated automatically.
*
* Please note that the minimum size is limited by the size of the header
* while the maximum size is limited by the maximum allowed message size.
*/
size_t messageSize;
private:
/**
* @brief This is the internal buffer that contains the
* actual message data.
*/
uint8_t internalBuffer[MAX_MESSAGE_SIZE] = {};
}; };
#endif /* FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ */ #endif /* FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ */

View File

@ -14,7 +14,7 @@ class MessageQueueMessageIF {
*/ */
static const size_t HEADER_SIZE = sizeof(MessageQueueId_t); static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);
virtual ~MessageQueueMessageIF(){}; virtual ~MessageQueueMessageIF() = default;
/** /**
* @brief With this method, the whole content and the message * @brief With this method, the whole content and the message
@ -29,7 +29,7 @@ class MessageQueueMessageIF {
* @brief Get read-only pointer to the complete data of the message. * @brief Get read-only pointer to the complete data of the message.
* @return * @return
*/ */
virtual const uint8_t* getBuffer() const = 0; [[nodiscard]] virtual const uint8_t* getBuffer() const = 0;
/** /**
* @brief This method is used to get the complete data of the message. * @brief This method is used to get the complete data of the message.
@ -48,14 +48,14 @@ class MessageQueueMessageIF {
* @brief This method is used to extract the sender's message queue id * @brief This method is used to extract the sender's message queue id
* information from a received message. * information from a received message.
*/ */
virtual MessageQueueId_t getSender() const = 0; [[nodiscard]] virtual MessageQueueId_t getSender() const = 0;
/** /**
* @brief This method is used to fetch the data content of the message. * @brief This method is used to fetch the data content of the message.
* @details * @details
* It shall be used by child classes to add data at the right position. * It shall be used by child classes to add data at the right position.
*/ */
virtual const uint8_t* getData() const = 0; [[nodiscard]] virtual const uint8_t* getData() const = 0;
/** /**
* @brief This method is used to fetch the data content of the message. * @brief This method is used to fetch the data content of the message.
* @details * @details
@ -67,12 +67,28 @@ class MessageQueueMessageIF {
* Get constant message size of current message implementation. * Get constant message size of current message implementation.
* @return * @return
*/ */
virtual size_t getMessageSize() const = 0; [[nodiscard]] virtual size_t getMessageSize() const = 0;
/**
* Sets the current message size of a given message
* @param messageSize
*/
virtual void setMessageSize(size_t messageSize) = 0; virtual void setMessageSize(size_t messageSize) = 0;
virtual size_t getMinimumMessageSize() const = 0; /**
virtual size_t getMaximumMessageSize() const = 0; * Returns the smallest possible message size, including any headers
virtual size_t getMaximumDataSize() const = 0; * @return
*/
[[nodiscard]] virtual size_t getMinimumMessageSize() const = 0;
/**
* Returns the largest possible message size, including any headers
* @return
*/
[[nodiscard]] virtual size_t getMaximumMessageSize() const = 0;
/**
* Returns the largest possible data size without any headers
* @return
*/
[[nodiscard]] virtual size_t getMaximumDataSize() const = 0;
}; };
#endif /* FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_ */ #endif /* FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_ */

View File

@ -1,14 +1,14 @@
#ifndef FSFW_IPC_MESSAGEQUEUESENDERIF_H_ #ifndef FSFW_IPC_MESSAGEQUEUESENDERIF_H_
#define FSFW_IPC_MESSAGEQUEUESENDERIF_H_ #define FSFW_IPC_MESSAGEQUEUESENDERIF_H_
#include "../objectmanager/ObjectManagerIF.h"
#include "MessageQueueIF.h" #include "MessageQueueIF.h"
#include "MessageQueueMessageIF.h" #include "MessageQueueMessageIF.h"
#include "fsfw/objectmanager/ObjectManagerIF.h"
class MessageQueueSenderIF { class MessageQueueSenderIF {
public: public:
virtual ~MessageQueueSenderIF() {} virtual ~MessageQueueSenderIF() = default;
MessageQueueSenderIF() = delete;
/** /**
* Allows sending messages without actually "owning" a message queue. * Allows sending messages without actually "owning" a message queue.
* Not sure whether this is actually a good idea. * Not sure whether this is actually a good idea.
@ -16,9 +16,6 @@ class MessageQueueSenderIF {
static ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message, static ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
MessageQueueId_t sentFrom = MessageQueueIF::NO_QUEUE, MessageQueueId_t sentFrom = MessageQueueIF::NO_QUEUE,
bool ignoreFault = false); bool ignoreFault = false);
private:
MessageQueueSenderIF() {}
}; };
#endif /* FSFW_IPC_MESSAGEQUEUESENDERIF_H_ */ #endif /* FSFW_IPC_MESSAGEQUEUESENDERIF_H_ */

View File

@ -34,7 +34,7 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
SerializeElement<T> limitValue; SerializeElement<T> limitValue;
SerializeElement<ReturnValue_t> oldState; SerializeElement<ReturnValue_t> oldState;
SerializeElement<ReturnValue_t> newState; SerializeElement<ReturnValue_t> newState;
uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE] = {}; uint8_t rawTimestamp[TimeStamperIF::MAXIMUM_TIMESTAMP_LEN] = {};
SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer; SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
TimeStamperIF* timeStamper; TimeStamperIF* timeStamper;
MonitoringReportContent() MonitoringReportContent()
@ -47,7 +47,7 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
oldState(0), oldState(0),
newState(0), newState(0),
timestampSerializer(rawTimestamp, sizeof(rawTimestamp)), timestampSerializer(rawTimestamp, sizeof(rawTimestamp)),
timeStamper(NULL) { timeStamper(nullptr) {
setAllNext(); setAllNext();
} }
MonitoringReportContent(gp_id_t globalPoolId, T value, T limitValue, ReturnValue_t oldState, MonitoringReportContent(gp_id_t globalPoolId, T value, T limitValue, ReturnValue_t oldState,
@ -61,7 +61,7 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
oldState(oldState), oldState(oldState),
newState(newState), newState(newState),
timestampSerializer(rawTimestamp, sizeof(rawTimestamp)), timestampSerializer(rawTimestamp, sizeof(rawTimestamp)),
timeStamper(NULL) { timeStamper(nullptr) {
setAllNext(); setAllNext();
if (checkAndSetStamper()) { if (checkAndSetStamper()) {
timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp)); timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));

View File

@ -21,7 +21,7 @@ void ObjectManager::setObjectFactoryFunction(produce_function_t objFactoryFunc,
this->factoryArgs = factoryArgs; this->factoryArgs = factoryArgs;
} }
ObjectManager::ObjectManager() {} ObjectManager::ObjectManager() = default;
ObjectManager::~ObjectManager() { ObjectManager::~ObjectManager() {
for (auto const& iter : objectList) { for (auto const& iter : objectList) {
@ -36,7 +36,7 @@ ReturnValue_t ObjectManager::insert(object_id_t id, SystemObjectIF* object) {
// sif::debug << "ObjectManager::insert: Object " << std::hex // sif::debug << "ObjectManager::insert: Object " << std::hex
// << (int)id << std::dec << " inserted." << std::endl; // << (int)id << std::dec << " inserted." << std::endl;
#endif #endif
return this->RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} else { } else {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "ObjectManager::insert: Object ID " << std::hex << static_cast<uint32_t>(id) sif::error << "ObjectManager::insert: Object ID " << std::hex << static_cast<uint32_t>(id)
@ -53,7 +53,7 @@ ReturnValue_t ObjectManager::insert(object_id_t id, SystemObjectIF* object) {
} }
ReturnValue_t ObjectManager::remove(object_id_t id) { ReturnValue_t ObjectManager::remove(object_id_t id) {
if (this->getSystemObject(id) != NULL) { if (this->getSystemObject(id) != nullptr) {
this->objectList.erase(id); this->objectList.erase(id);
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
// sif::debug << "ObjectManager::removeObject: Object " << std::hex // sif::debug << "ObjectManager::removeObject: Object " << std::hex

View File

@ -38,7 +38,7 @@ class ObjectManager : public ObjectManagerIF {
/** /**
* @brief In the class's destructor, all objects in the list are deleted. * @brief In the class's destructor, all objects in the list are deleted.
*/ */
virtual ~ObjectManager(); ~ObjectManager() override;
ReturnValue_t insert(object_id_t id, SystemObjectIF* object) override; ReturnValue_t insert(object_id_t id, SystemObjectIF* object) override;
ReturnValue_t remove(object_id_t id) override; ReturnValue_t remove(object_id_t id) override;
void initialize() override; void initialize() override;

View File

@ -33,6 +33,7 @@ enum framework_objects : object_id_t {
TC_STORE = 0x534f0100, TC_STORE = 0x534f0100,
TM_STORE = 0x534f0200, TM_STORE = 0x534f0200,
TIME_STAMPER = 0x53500010, TIME_STAMPER = 0x53500010,
VERIFICATION_REPORTER = 0x53500020,
FSFW_OBJECTS_END = 0x53ffffff, FSFW_OBJECTS_END = 0x53ffffff,
NO_OBJECT = 0xFFFFFFFF NO_OBJECT = 0xFFFFFFFF

View File

@ -108,7 +108,7 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
StorageManagerIF* tmStore = nullptr; StorageManagerIF* tmStore = nullptr;
private: private:
static constexpr ReturnValue_t CONN_BROKEN = HasReturnvaluesIF::makeReturnCode(1, 0); static constexpr ReturnValue_t CONN_BROKEN = result::makeCode(1, 0);
//! TMTC bridge is cached. //! TMTC bridge is cached.
object_id_t tmtcBridgeId = objects::NO_OBJECT; object_id_t tmtcBridgeId = objects::NO_OBJECT;
TcpTmTcBridge* tmtcBridge = nullptr; TcpTmTcBridge* tmtcBridge = nullptr;

View File

@ -146,7 +146,7 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
} }
ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) { ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
struct tm time_tm; struct tm time_tm {};
time_tm.tm_year = from->year - 1900; time_tm.tm_year = from->year - 1900;
time_tm.tm_mon = from->month - 1; time_tm.tm_mon = from->month - 1;

View File

@ -65,11 +65,11 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
// But I will still return a failure here. // But I will still return a failure here.
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
MessageQueue* targetQueue = auto* targetQueue =
dynamic_cast<MessageQueue*>(QueueMapManager::instance()->getMessageQueue(sendTo)); dynamic_cast<MessageQueue*>(QueueMapManager::instance()->getMessageQueue(sendTo));
if (targetQueue == nullptr) { if (targetQueue == nullptr) {
if (not ignoreFault) { if (not ignoreFault) {
InternalErrorReporterIF* internalErrorReporter = auto* internalErrorReporter =
ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER); ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
if (internalErrorReporter != nullptr) { if (internalErrorReporter != nullptr) {
internalErrorReporter->queueMessageNotSent(); internalErrorReporter->queueMessageNotSent();
@ -84,7 +84,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
message->getMaximumMessageSize()); message->getMaximumMessageSize());
} else { } else {
if (not ignoreFault) { if (not ignoreFault) {
InternalErrorReporterIF* internalErrorReporter = auto* internalErrorReporter =
ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER); ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
if (internalErrorReporter != nullptr) { if (internalErrorReporter != nullptr) {
internalErrorReporter->queueMessageNotSent(); internalErrorReporter->queueMessageNotSent();

View File

@ -68,7 +68,7 @@ class MessageQueue : public MessageQueueBase {
* @details This is accomplished by using the delete call provided * @details This is accomplished by using the delete call provided
* by the operating system. * by the operating system.
*/ */
virtual ~MessageQueue(); ~MessageQueue() override;
// Implement non-generic MessageQueueIF functions not handled by MessageQueueBase // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message, virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
@ -111,8 +111,6 @@ class MessageQueue : public MessageQueueBase {
size_t messageDepth = 0; size_t messageDepth = 0;
MutexIF* queueLock; MutexIF* queueLock;
MessageQueueId_t defaultDestination = MessageQueueIF::NO_QUEUE;
}; };
#endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */ #endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */

View File

@ -13,7 +13,6 @@ ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
MessageQueueMessageIF* message, MessageQueueMessageIF* message,
MessageQueueId_t sentFrom, bool ignoreFault) { MessageQueueId_t sentFrom, bool ignoreFault) {
return MessageQueue::sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault); return MessageQueue::sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault);
return HasReturnvaluesIF::RETURN_OK;
} }
QueueFactory* QueueFactory::instance() { QueueFactory* QueueFactory::instance() {
@ -23,9 +22,9 @@ QueueFactory* QueueFactory::instance() {
return factoryInstance; return factoryInstance;
} }
QueueFactory::QueueFactory() {} QueueFactory::QueueFactory() = default;
QueueFactory::~QueueFactory() {} QueueFactory::~QueueFactory() = default;
MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize, MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize,
MqArgs* args) { MqArgs* args) {

View File

@ -54,7 +54,7 @@ MessageQueueIF* QueueMapManager::getMessageQueue(MessageQueueId_t messageQueueId
} else { } else {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "QueueMapManager::getQueueHandle: The ID " << messageQueueId sif::warning << "QueueMapManager::getQueueHandle: The ID " << messageQueueId
<< " does not exists in the map!" << std::endl; << " does not exist in the map" << std::endl;
#else #else
sif::printWarning("QueueMapManager::getQueueHandle: The ID %d does not exist in the map!\n", sif::printWarning("QueueMapManager::getQueueHandle: The ID %d does not exist in the map!\n",
messageQueueId); messageQueueId);

View File

@ -2,23 +2,22 @@
#include <linux/sysinfo.h> #include <linux/sysinfo.h>
#include <sys/sysinfo.h> #include <sys/sysinfo.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h> #include <unistd.h>
#include <ctime>
#include <fstream> #include <fstream>
#include "fsfw/ipc/MutexGuard.h" #include "fsfw/ipc/MutexGuard.h"
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/serviceinterface/ServiceInterface.h"
uint32_t Clock::getTicksPerSecond(void) { uint32_t Clock::getTicksPerSecond() {
uint32_t ticks = sysconf(_SC_CLK_TCK); uint32_t ticks = sysconf(_SC_CLK_TCK);
return ticks; return ticks;
} }
ReturnValue_t Clock::setClock(const TimeOfDay_t* time) { ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
timespec timeUnix; timespec timeUnix{};
timeval timeTimeval; timeval timeTimeval{};
convertTimeOfDayToTimeval(time, &timeTimeval); convertTimeOfDayToTimeval(time, &timeTimeval);
timeUnix.tv_sec = timeTimeval.tv_sec; timeUnix.tv_sec = timeTimeval.tv_sec;
timeUnix.tv_nsec = (__syscall_slong_t)timeTimeval.tv_usec * 1000; timeUnix.tv_nsec = (__syscall_slong_t)timeTimeval.tv_usec * 1000;
@ -32,7 +31,7 @@ ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
} }
ReturnValue_t Clock::setClock(const timeval* time) { ReturnValue_t Clock::setClock(const timeval* time) {
timespec timeUnix; timespec timeUnix{};
timeUnix.tv_sec = time->tv_sec; timeUnix.tv_sec = time->tv_sec;
timeUnix.tv_nsec = (__syscall_slong_t)time->tv_usec * 1000; timeUnix.tv_nsec = (__syscall_slong_t)time->tv_usec * 1000;
int status = clock_settime(CLOCK_REALTIME, &timeUnix); int status = clock_settime(CLOCK_REALTIME, &timeUnix);
@ -44,7 +43,7 @@ ReturnValue_t Clock::setClock(const timeval* time) {
} }
ReturnValue_t Clock::getClock_timeval(timeval* time) { ReturnValue_t Clock::getClock_timeval(timeval* time) {
timespec timeUnix; timespec timeUnix{};
int status = clock_gettime(CLOCK_REALTIME, &timeUnix); int status = clock_gettime(CLOCK_REALTIME, &timeUnix);
if (status != 0) { if (status != 0) {
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
@ -55,18 +54,18 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
} }
ReturnValue_t Clock::getClock_usecs(uint64_t* time) { ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
timeval timeVal; timeval timeVal{};
ReturnValue_t result = getClock_timeval(&timeVal); ReturnValue_t result = getClock_timeval(&timeVal);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
*time = (uint64_t)timeVal.tv_sec * 1e6 + timeVal.tv_usec; *time = static_cast<uint64_t>(timeVal.tv_sec) * 1e6 + timeVal.tv_usec;
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
timeval Clock::getUptime() { timeval Clock::getUptime() {
timeval uptime; timeval uptime{};
auto result = getUptime(&uptime); auto result = getUptime(&uptime);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
@ -99,7 +98,7 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
//} //}
ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) { ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
timeval uptime; timeval uptime{};
ReturnValue_t result = getUptime(&uptime); ReturnValue_t result = getUptime(&uptime);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
@ -109,7 +108,7 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
} }
ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) { ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
timespec timeUnix; timespec timeUnix{};
int status = clock_gettime(CLOCK_REALTIME, &timeUnix); int status = clock_gettime(CLOCK_REALTIME, &timeUnix);
if (status != 0) { if (status != 0) {
// TODO errno // TODO errno
@ -122,7 +121,7 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
MutexGuard helper(timeMutex); MutexGuard helper(timeMutex);
// gmtime writes its output in a global buffer which is not Thread Safe // gmtime writes its output in a global buffer which is not Thread Safe
// Therefore we have to use a Mutex here // Therefore we have to use a Mutex here
struct tm* timeInfo; struct std::tm* timeInfo;
timeInfo = gmtime(&timeUnix.tv_sec); timeInfo = gmtime(&timeUnix.tv_sec);
time->year = timeInfo->tm_year + 1900; time->year = timeInfo->tm_year + 1900;
time->month = timeInfo->tm_mon + 1; time->month = timeInfo->tm_mon + 1;
@ -136,7 +135,7 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
} }
ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) { ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
tm fromTm; std::tm fromTm{};
// Note: Fails for years before AD // Note: Fails for years before AD
fromTm.tm_year = from->year - 1900; fromTm.tm_year = from->year - 1900;
fromTm.tm_mon = from->month - 1; fromTm.tm_mon = from->month - 1;

View File

@ -44,7 +44,7 @@ store_address_t ParameterMessage::getParameterLoadCommand(const CommandMessage*
*pfc = packedParamSettings >> 16 & 0xff; *pfc = packedParamSettings >> 16 & 0xff;
*rows = packedParamSettings >> 8 & 0xff; *rows = packedParamSettings >> 8 & 0xff;
*columns = packedParamSettings & 0xff; *columns = packedParamSettings & 0xff;
return message->getParameter2(); return static_cast<store_address_t>(message->getParameter2());
} }
void ParameterMessage::clear(CommandMessage* message) { void ParameterMessage::clear(CommandMessage* message) {

View File

@ -96,13 +96,13 @@ ReturnValue_t CService200ModeCommanding::handleReply(const CommandMessage *reply
ReturnValue_t CService200ModeCommanding::prepareModeReply(const CommandMessage *reply, ReturnValue_t CService200ModeCommanding::prepareModeReply(const CommandMessage *reply,
object_id_t objectId) { object_id_t objectId) {
ModePacket modeReplyPacket(objectId, ModeMessage::getMode(reply), ModeMessage::getSubmode(reply)); ModePacket modeReplyPacket(objectId, ModeMessage::getMode(reply), ModeMessage::getSubmode(reply));
return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket); return sendTmPacket(Subservice::REPLY_MODE_REPLY, modeReplyPacket);
} }
ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(const CommandMessage *reply, ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(const CommandMessage *reply,
object_id_t objectId) { object_id_t objectId) {
ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply), ModeMessage::getSubmode(reply)); ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply), ModeMessage::getSubmode(reply));
ReturnValue_t result = sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply); ReturnValue_t result = sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, wrongModeReply);
if (result == RETURN_OK) { if (result == RETURN_OK) {
// We want to produce an error here in any case because the mode was not correct // We want to produce an error here in any case because the mode was not correct
return RETURN_FAILED; return RETURN_FAILED;
@ -113,7 +113,7 @@ ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(const CommandMess
ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(const CommandMessage *reply, ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(const CommandMessage *reply,
object_id_t objectId) { object_id_t objectId) {
CantReachModePacket cantReachModePacket(objectId, ModeMessage::getCantReachModeReason(reply)); CantReachModePacket cantReachModePacket(objectId, ModeMessage::getCantReachModeReason(reply));
ReturnValue_t result = sendTmPacket(Subservice::REPLY_CANT_REACH_MODE, &cantReachModePacket); ReturnValue_t result = sendTmPacket(Subservice::REPLY_CANT_REACH_MODE, cantReachModePacket);
if (result == RETURN_OK) { if (result == RETURN_OK) {
// We want to produce an error here in any case because the mode was not reached // We want to produce an error here in any case because the mode was not reached
return RETURN_FAILED; return RETURN_FAILED;

View File

@ -102,5 +102,5 @@ ReturnValue_t CService201HealthCommanding::handleReply(const CommandMessage *rep
auto health = static_cast<uint8_t>(HealthMessage::getHealth(reply)); auto health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
auto oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply)); auto oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
HealthSetReply healthSetReply(health, oldHealth); HealthSetReply healthSetReply(health, oldHealth);
return sendTmPacket(Subservice::REPLY_HEALTH_SET, &healthSetReply); return sendTmPacket(Subservice::REPLY_HEALTH_SET, healthSetReply);
} }

View File

@ -74,8 +74,7 @@ class Service11TelecommandScheduling final : public PusServiceBase {
TO_TIMETAG = 3 TO_TIMETAG = 3
}; };
Service11TelecommandScheduling(object_id_t objectId, uint16_t apid, uint8_t serviceId, Service11TelecommandScheduling(PsbParams params, AcceptsTelecommandsIF* tcRecipient,
AcceptsTelecommandsIF* tcRecipient,
uint16_t releaseTimeMarginSeconds = DEFAULT_RELEASE_TIME_MARGIN, uint16_t releaseTimeMarginSeconds = DEFAULT_RELEASE_TIME_MARGIN,
bool debugMode = false); bool debugMode = false);
@ -159,7 +158,7 @@ class Service11TelecommandScheduling final : public PusServiceBase {
* @param data The Application data of the TC (get via getApplicationData()). * @param data The Application data of the TC (get via getApplicationData()).
* @return requestId * @return requestId
*/ */
uint64_t getRequestIdFromDataTC(const uint8_t* data) const; [[nodiscard]] uint64_t getRequestIdFromTc() const;
/** /**
* @brief Extracts the Request ID from the Application Data directly, assuming it is packed * @brief Extracts the Request ID from the Application Data directly, assuming it is packed

View File

@ -11,9 +11,9 @@ static constexpr auto DEF_END = SerializeIF::Endianness::BIG;
template <size_t MAX_NUM_TCS> template <size_t MAX_NUM_TCS>
inline Service11TelecommandScheduling<MAX_NUM_TCS>::Service11TelecommandScheduling( inline Service11TelecommandScheduling<MAX_NUM_TCS>::Service11TelecommandScheduling(
object_id_t objectId, uint16_t apid, uint8_t serviceId, AcceptsTelecommandsIF *tcRecipient, PsbParams params, AcceptsTelecommandsIF *tcRecipient, uint16_t releaseTimeMarginSeconds,
uint16_t releaseTimeMarginSeconds, bool debugMode) bool debugMode)
: PusServiceBase(objectId, apid, serviceId), : PusServiceBase(params),
RELEASE_TIME_MARGIN_SECONDS(releaseTimeMarginSeconds), RELEASE_TIME_MARGIN_SECONDS(releaseTimeMarginSeconds),
debugMode(debugMode), debugMode(debugMode),
tcRecipient(tcRecipient) {} tcRecipient(tcRecipient) {}
@ -32,11 +32,8 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::handleRequest(
#endif #endif
} }
// Get de-serialized Timestamp // Get de-serialized Timestamp
const uint8_t *data = currentPacket.getApplicationData(); const uint8_t *data = currentPacket.getUserData();
size_t size = currentPacket.getApplicationDataSize(); size_t size = currentPacket.getUserDataLen();
if (data == nullptr) {
return handleInvalidData("handleRequest");
}
switch (subservice) { switch (subservice) {
case Subservice::ENABLE_SCHEDULING: { case Subservice::ENABLE_SCHEDULING: {
schedulingEnabled = true; schedulingEnabled = true;
@ -82,7 +79,7 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::performService
if (schedulingEnabled) { if (schedulingEnabled) {
// release tc // release tc
TmTcMessage releaseMsg(it->second.storeAddr); TmTcMessage releaseMsg(it->second.storeAddr);
auto sendRet = this->requestQueue->sendMessage(recipientMsgQueueId, &releaseMsg, false); auto sendRet = psbParams.reqQueue->sendMessage(recipientMsgQueueId, &releaseMsg, false);
if (sendRet != HasReturnvaluesIF::RETURN_OK) { if (sendRet != HasReturnvaluesIF::RETURN_OK) {
return sendRet; return sendRet;
@ -175,7 +172,7 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doInsertActivi
// store currentPacket and receive the store address // store currentPacket and receive the store address
store_address_t addr{}; store_address_t addr{};
if (tcStore->addData(&addr, data, size) != RETURN_OK || if (tcStore->addData(&addr, data, size) != RETURN_OK ||
addr.raw == storeId::INVALID_STORE_ADDRESS) { addr.raw == store_address_t::INVALID_RAW) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "Service11TelecommandScheduling::doInsertActivity: Adding data to TC Store failed" sif::error << "Service11TelecommandScheduling::doInsertActivity: Adding data to TC Store failed"
<< std::endl; << std::endl;
@ -190,8 +187,7 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doInsertActivi
TelecommandStruct tc; TelecommandStruct tc;
tc.seconds = timestamp; tc.seconds = timestamp;
tc.storeAddr = addr; tc.storeAddr = addr;
tc.requestId = tc.requestId = getRequestIdFromTc(); // TODO: Missing sanity check of the returned request id
getRequestIdFromDataTC(data); // TODO: Missing sanity check of the returned request id
auto it = telecommandMap.insert(std::pair<uint32_t, TelecommandStruct>(timestamp, tc)); auto it = telecommandMap.insert(std::pair<uint32_t, TelecommandStruct>(timestamp, tc));
if (it == telecommandMap.end()) { if (it == telecommandMap.end()) {
@ -455,13 +451,10 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doFilterTimesh
} }
template <size_t MAX_NUM_TCS> template <size_t MAX_NUM_TCS>
inline uint64_t Service11TelecommandScheduling<MAX_NUM_TCS>::getRequestIdFromDataTC( inline uint64_t Service11TelecommandScheduling<MAX_NUM_TCS>::getRequestIdFromTc() const {
const uint8_t *data) const { uint32_t sourceId = currentPacket.getSourceId();
TcPacketPus mask(data); uint16_t apid = currentPacket.getApid();
uint16_t sequenceCount = currentPacket.getSequenceCount();
uint32_t sourceId = mask.getSourceId();
uint16_t apid = mask.getAPID();
uint16_t sequenceCount = mask.getPacketSequenceCount();
return buildRequestId(sourceId, apid, sequenceCount); return buildRequestId(sourceId, apid, sequenceCount);
} }

View File

@ -1,39 +1,33 @@
#include "fsfw/pus/Service17Test.h" #include "fsfw/pus/Service17Test.h"
#include "fsfw/FSFW.h" #include "fsfw/FSFW.h"
#include "fsfw/objectmanager/ObjectManager.h"
#include "fsfw/objectmanager/SystemObject.h" #include "fsfw/objectmanager/SystemObject.h"
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/tmtcservices/tmHelpers.h"
#include "fsfw/tmtcpacket/pus/tm/TmPacketStored.h"
Service17Test::Service17Test(object_id_t objectId, uint16_t apid, uint8_t serviceId) Service17Test::Service17Test(PsbParams params)
: PusServiceBase(objectId, apid, serviceId), packetSubCounter(0) {} : PusServiceBase(params),
storeHelper(params.apid),
tmHelper(params.serviceId, storeHelper, sendHelper) {}
Service17Test::~Service17Test() {} Service17Test::~Service17Test() = default;
ReturnValue_t Service17Test::handleRequest(uint8_t subservice) { ReturnValue_t Service17Test::handleRequest(uint8_t subservice) {
switch (subservice) { switch (subservice) {
case Subservice::CONNECTION_TEST: { case Subservice::CONNECTION_TEST: {
#if FSFW_USE_PUS_C_TELEMETRY == 0 ReturnValue_t result = tmHelper.prepareTmPacket(Subservice::CONNECTION_TEST_REPORT);
TmPacketStoredPusA connectionPacket(apid, serviceId, Subservice::CONNECTION_TEST_REPORT, if (result != HasReturnvaluesIF::RETURN_OK) {
packetSubCounter++); return result;
#else }
TmPacketStoredPusC connectionPacket(apid, serviceId, Subservice::CONNECTION_TEST_REPORT, return tmHelper.storeAndSendTmPacket();
packetSubCounter++);
#endif
connectionPacket.sendPacket(requestQueue->getDefaultDestination(), requestQueue->getId());
return HasReturnvaluesIF::RETURN_OK;
} }
case Subservice::EVENT_TRIGGER_TEST: { case Subservice::EVENT_TRIGGER_TEST: {
#if FSFW_USE_PUS_C_TELEMETRY == 0
TmPacketStoredPusA connectionPacket(apid, serviceId, Subservice::CONNECTION_TEST_REPORT,
packetSubCounter++);
#else
TmPacketStoredPusC connectionPacket(apid, serviceId, Subservice::CONNECTION_TEST_REPORT,
packetSubCounter++);
#endif
connectionPacket.sendPacket(requestQueue->getDefaultDestination(), requestQueue->getId());
triggerEvent(TEST, 1234, 5678); triggerEvent(TEST, 1234, 5678);
return RETURN_OK; ReturnValue_t result = tmHelper.prepareTmPacket(Subservice::EVENT_TRIGGER_TEST);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return tmHelper.storeAndSendTmPacket();
} }
default: default:
return AcceptsTelecommandsIF::INVALID_SUBSERVICE; return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
@ -41,3 +35,23 @@ ReturnValue_t Service17Test::handleRequest(uint8_t subservice) {
} }
ReturnValue_t Service17Test::performService() { return HasReturnvaluesIF::RETURN_OK; } ReturnValue_t Service17Test::performService() { return HasReturnvaluesIF::RETURN_OK; }
ReturnValue_t Service17Test::initialize() {
ReturnValue_t result = PusServiceBase::initialize();
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
initializeTmHelpers(sendHelper, storeHelper);
if (storeHelper.getTmStore() == nullptr) {
auto* tmStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TM_STORE);
if (tmStore == nullptr) {
return ObjectManagerIF::CHILD_INIT_FAILED;
}
storeHelper.setTmStore(*tmStore);
}
return result;
}
void Service17Test::setCustomTmStore(StorageManagerIF& tmStore_) {
storeHelper.setTmStore(tmStore_);
}

View File

@ -3,6 +3,8 @@
#include "fsfw/objectmanager/SystemObject.h" #include "fsfw/objectmanager/SystemObject.h"
#include "fsfw/tmtcservices/PusServiceBase.h" #include "fsfw/tmtcservices/PusServiceBase.h"
#include "fsfw/tmtcservices/TmStoreAndSendHelper.h"
#include "fsfw/tmtcservices/TmStoreHelper.h"
/** /**
* @brief Test Service * @brief Test Service
@ -32,13 +34,19 @@ class Service17Test : public PusServiceBase {
EVENT_TRIGGER_TEST = 128, EVENT_TRIGGER_TEST = 128,
}; };
Service17Test(object_id_t objectId, uint16_t apid, uint8_t serviceId); explicit Service17Test(PsbParams params);
virtual ~Service17Test();
virtual ReturnValue_t handleRequest(uint8_t subservice) override; void setCustomTmStore(StorageManagerIF& tmStore);
virtual ReturnValue_t performService() override;
~Service17Test() override;
ReturnValue_t handleRequest(uint8_t subservice) override;
ReturnValue_t performService() override;
ReturnValue_t initialize() override;
protected: protected:
uint16_t packetSubCounter = 0; TmStoreHelper storeHelper;
TmSendHelper sendHelper;
TmStoreAndSendWrapper tmHelper;
}; };
#endif /* FSFW_PUS_SERVICE17TEST_H_ */ #endif /* FSFW_PUS_SERVICE17TEST_H_ */

View File

@ -3,22 +3,22 @@
#include "fsfw/ipc/QueueFactory.h" #include "fsfw/ipc/QueueFactory.h"
#include "fsfw/objectmanager/ObjectManager.h" #include "fsfw/objectmanager/ObjectManager.h"
#include "fsfw/pus/servicepackets/Service1Packets.h" #include "fsfw/pus/servicepackets/Service1Packets.h"
#include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/tmtcpacket/pus/tm/TmPacketStored.h"
#include "fsfw/tmtcservices/AcceptsTelemetryIF.h" #include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
#include "fsfw/tmtcservices/PusVerificationReport.h" #include "fsfw/tmtcservices/PusVerificationReport.h"
#include "fsfw/tmtcservices/tmHelpers.h"
Service1TelecommandVerification::Service1TelecommandVerification(object_id_t objectId, Service1TelecommandVerification::Service1TelecommandVerification(object_id_t objectId,
uint16_t apid, uint8_t serviceId, uint16_t apid, uint8_t serviceId,
object_id_t targetDestination, object_id_t targetDestination,
uint16_t messageQueueDepth) uint16_t messageQueueDepth,
TimeStamperIF* timeStamper)
: SystemObject(objectId), : SystemObject(objectId),
apid(apid), apid(apid),
serviceId(serviceId), serviceId(serviceId),
targetDestination(targetDestination) { targetDestination(targetDestination),
auto mqArgs = MqArgs(objectId, static_cast<void*>(this)); storeHelper(apid),
tmQueue = QueueFactory::instance()->createMessageQueue( tmHelper(serviceId, storeHelper, sendHelper) {
messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs); tmQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
} }
Service1TelecommandVerification::~Service1TelecommandVerification() { Service1TelecommandVerification::~Service1TelecommandVerification() {
@ -49,6 +49,19 @@ ReturnValue_t Service1TelecommandVerification::performOperation(uint8_t operatio
ReturnValue_t Service1TelecommandVerification::sendVerificationReport( ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
PusVerificationMessage* message) { PusVerificationMessage* message) {
ReturnValue_t result; ReturnValue_t result;
uint8_t reportId = message->getReportId();
if (reportId == 0 or reportId > 8) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "Service1TelecommandVerification::sendVerificationReport: Invalid report ID "
<< static_cast<int>(reportId) << " detected" << std::endl;
#else
sif::printError(
"Service1TelecommandVerification::sendVerificationReport: Invalid report ID "
"%d detected\n",
reportId);
#endif
return HasReturnvaluesIF::RETURN_FAILED;
}
if (message->getReportId() % 2 == 0) { if (message->getReportId() % 2 == 0) {
result = generateFailureReport(message); result = generateFailureReport(message);
} else { } else {
@ -69,32 +82,37 @@ ReturnValue_t Service1TelecommandVerification::generateFailureReport(
FailureReport report(message->getReportId(), message->getTcPacketId(), FailureReport report(message->getReportId(), message->getTcPacketId(),
message->getTcSequenceControl(), message->getStep(), message->getErrorCode(), message->getTcSequenceControl(), message->getStep(), message->getErrorCode(),
message->getParameter1(), message->getParameter2()); message->getParameter1(), message->getParameter2());
#if FSFW_USE_PUS_C_TELEMETRY == 0 ReturnValue_t result =
TmPacketStoredPusA tmPacket(apid, serviceId, message->getReportId(), packetSubCounter++, &report); storeHelper.preparePacket(serviceId, message->getReportId(), packetSubCounter++);
#else if (result != HasReturnvaluesIF::RETURN_OK) {
TmPacketStoredPusC tmPacket(apid, serviceId, message->getReportId(), packetSubCounter++, &report); return result;
#endif }
ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(), tmQueue->getId()); result = storeHelper.setSourceDataSerializable(report);
return result; if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return tmHelper.storeAndSendTmPacket();
} }
ReturnValue_t Service1TelecommandVerification::generateSuccessReport( ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
PusVerificationMessage* message) { PusVerificationMessage* message) {
SuccessReport report(message->getReportId(), message->getTcPacketId(), SuccessReport report(message->getReportId(), message->getTcPacketId(),
message->getTcSequenceControl(), message->getStep()); message->getTcSequenceControl(), message->getStep());
#if FSFW_USE_PUS_C_TELEMETRY == 0 ReturnValue_t result =
TmPacketStoredPusA tmPacket(apid, serviceId, message->getReportId(), packetSubCounter++, &report); storeHelper.preparePacket(serviceId, message->getReportId(), packetSubCounter++);
#else if (result != HasReturnvaluesIF::RETURN_OK) {
TmPacketStoredPusC tmPacket(apid, serviceId, message->getReportId(), packetSubCounter++, &report); return result;
#endif }
ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(), tmQueue->getId()); result = storeHelper.setSourceDataSerializable(report);
return result; if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return tmHelper.storeAndSendTmPacket();
} }
ReturnValue_t Service1TelecommandVerification::initialize() { ReturnValue_t Service1TelecommandVerification::initialize() {
// Get target object for TC verification messages // Get target object for TC verification messages
AcceptsTelemetryIF* funnel = auto* funnel = ObjectManager::instance()->get<AcceptsTelemetryIF>(targetDestination);
ObjectManager::instance()->get<AcceptsTelemetryIF>(targetDestination);
if (funnel == nullptr) { if (funnel == nullptr) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "Service1TelecommandVerification::initialize: Specified" sif::error << "Service1TelecommandVerification::initialize: Specified"
@ -104,6 +122,33 @@ ReturnValue_t Service1TelecommandVerification::initialize() {
#endif #endif
return ObjectManagerIF::CHILD_INIT_FAILED; return ObjectManagerIF::CHILD_INIT_FAILED;
} }
if (tmQueue == nullptr) {
return ObjectManagerIF::CHILD_INIT_FAILED;
}
tmQueue->setDefaultDestination(funnel->getReportReceptionQueue()); tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
if (tmStore == nullptr) {
tmStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TM_STORE);
if (tmStore == nullptr) {
return ObjectManager::CHILD_INIT_FAILED;
}
storeHelper.setTmStore(*tmStore);
}
if (timeStamper == nullptr) {
timeStamper = ObjectManager::instance()->get<TimeStamperIF>(objects::TIME_STAMPER);
if (timeStamper == nullptr) {
return ObjectManagerIF::CHILD_INIT_FAILED;
}
} else {
}
storeHelper.setTimeStamper(*timeStamper);
sendHelper.setMsgQueue(*tmQueue);
if (errReporter == nullptr) {
errReporter =
ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
if (errReporter != nullptr) {
sendHelper.setInternalErrorReporter(*errReporter);
}
}
return SystemObject::initialize(); return SystemObject::initialize();
} }

View File

@ -7,6 +7,9 @@
#include "fsfw/tasks/ExecutableObjectIF.h" #include "fsfw/tasks/ExecutableObjectIF.h"
#include "fsfw/tmtcservices/AcceptsVerifyMessageIF.h" #include "fsfw/tmtcservices/AcceptsVerifyMessageIF.h"
#include "fsfw/tmtcservices/PusVerificationReport.h" #include "fsfw/tmtcservices/PusVerificationReport.h"
#include "fsfw/tmtcservices/TmSendHelper.h"
#include "fsfw/tmtcservices/TmStoreAndSendHelper.h"
#include "fsfw/tmtcservices/TmStoreHelper.h"
/** /**
* @brief Verify TC acceptance, start, progress and execution. * @brief Verify TC acceptance, start, progress and execution.
@ -44,14 +47,15 @@ class Service1TelecommandVerification : public AcceptsVerifyMessageIF,
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1; static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
Service1TelecommandVerification(object_id_t objectId, uint16_t apid, uint8_t serviceId, Service1TelecommandVerification(object_id_t objectId, uint16_t apid, uint8_t serviceId,
object_id_t targetDestination, uint16_t messageQueueDepth); object_id_t targetDestination, uint16_t messageQueueDepth,
virtual ~Service1TelecommandVerification(); TimeStamperIF* timeStamper = nullptr);
~Service1TelecommandVerification() override;
/** /**
* *
* @return ID of Verification Queue * @return ID of Verification Queue
*/ */
virtual MessageQueueId_t getVerificationQueue() override; MessageQueueId_t getVerificationQueue() override;
/** /**
* Performs the service periodically as specified in init_mission(). * Performs the service periodically as specified in init_mission().
@ -59,7 +63,7 @@ class Service1TelecommandVerification : public AcceptsVerifyMessageIF,
* @param operationCode * @param operationCode
* @return * @return
*/ */
ReturnValue_t performOperation(uint8_t operationCode = 0) override; ReturnValue_t performOperation(uint8_t operationCode) override;
/** /**
* Initializes the destination for TC verification messages and initializes * Initializes the destination for TC verification messages and initializes
@ -80,6 +84,12 @@ class Service1TelecommandVerification : public AcceptsVerifyMessageIF,
uint16_t packetSubCounter = 0; uint16_t packetSubCounter = 0;
TmSendHelper sendHelper;
TmStoreHelper storeHelper;
TmStoreAndSendWrapper tmHelper;
InternalErrorReporterIF* errReporter = nullptr;
TimeStamperIF* timeStamper = nullptr;
StorageManagerIF* tmStore = nullptr;
MessageQueueIF* tmQueue = nullptr; MessageQueueIF* tmQueue = nullptr;
enum class Subservice : uint8_t { enum class Subservice : uint8_t {

View File

@ -14,7 +14,7 @@ Service20ParameterManagement::Service20ParameterManagement(object_id_t objectId,
: CommandingServiceBase(objectId, apid, serviceId, numberOfParallelCommands, : CommandingServiceBase(objectId, apid, serviceId, numberOfParallelCommands,
commandTimeoutSeconds) {} commandTimeoutSeconds) {}
Service20ParameterManagement::~Service20ParameterManagement() {} Service20ParameterManagement::~Service20ParameterManagement() = default;
ReturnValue_t Service20ParameterManagement::isValidSubservice(uint8_t subservice) { ReturnValue_t Service20ParameterManagement::isValidSubservice(uint8_t subservice) {
switch (static_cast<Subservice>(subservice)) { switch (static_cast<Subservice>(subservice)) {
@ -64,8 +64,7 @@ ReturnValue_t Service20ParameterManagement::checkAndAcquireTargetID(object_id_t*
ReturnValue_t Service20ParameterManagement::checkInterfaceAndAcquireMessageQueue( ReturnValue_t Service20ParameterManagement::checkInterfaceAndAcquireMessageQueue(
MessageQueueId_t* messageQueueToSet, object_id_t* objectId) { MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
// check ReceivesParameterMessagesIF property of target // check ReceivesParameterMessagesIF property of target
ReceivesParameterMessagesIF* possibleTarget = auto* possibleTarget = ObjectManager::instance()->get<ReceivesParameterMessagesIF>(*objectId);
ObjectManager::instance()->get<ReceivesParameterMessagesIF>(*objectId);
if (possibleTarget == nullptr) { if (possibleTarget == nullptr) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "Service20ParameterManagement::checkInterfaceAndAcquire" sif::error << "Service20ParameterManagement::checkInterfaceAndAcquire"
@ -137,7 +136,7 @@ ReturnValue_t Service20ParameterManagement::prepareLoadCommand(CommandMessage* m
if (parameterDataLen == 0) { if (parameterDataLen == 0) {
return CommandingServiceBase::INVALID_TC; return CommandingServiceBase::INVALID_TC;
} }
ReturnValue_t result = IPCStore->getFreeElement(&storeAddress, parameterDataLen, &storePointer); ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, parameterDataLen, &storePointer);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
@ -169,7 +168,7 @@ ReturnValue_t Service20ParameterManagement::handleReply(const CommandMessage* re
switch (replyId) { switch (replyId) {
case ParameterMessage::REPLY_PARAMETER_DUMP: { case ParameterMessage::REPLY_PARAMETER_DUMP: {
ConstAccessorPair parameterData = IPCStore->getData(ParameterMessage::getStoreId(reply)); ConstAccessorPair parameterData = ipcStore->getData(ParameterMessage::getStoreId(reply));
if (parameterData.first != HasReturnvaluesIF::RETURN_OK) { if (parameterData.first != HasReturnvaluesIF::RETURN_OK) {
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
@ -177,8 +176,7 @@ ReturnValue_t Service20ParameterManagement::handleReply(const CommandMessage* re
ParameterId_t parameterId = ParameterMessage::getParameterId(reply); ParameterId_t parameterId = ParameterMessage::getParameterId(reply);
ParameterDumpReply parameterReply(objectId, parameterId, parameterData.second.data(), ParameterDumpReply parameterReply(objectId, parameterId, parameterData.second.data(),
parameterData.second.size()); parameterData.second.size());
sendTmPacket(static_cast<uint8_t>(Subservice::PARAMETER_DUMP_REPLY), &parameterReply); return sendTmPacket(static_cast<uint8_t>(Subservice::PARAMETER_DUMP_REPLY), parameterReply);
return HasReturnvaluesIF::RETURN_OK;
} }
default: default:
return CommandingServiceBase::INVALID_REPLY; return CommandingServiceBase::INVALID_REPLY;

View File

@ -75,7 +75,7 @@ ReturnValue_t Service2DeviceAccess::prepareRawCommand(CommandMessage* messageToS
// store command into the Inter Process Communication Store // store command into the Inter Process Communication Store
store_address_t storeAddress; store_address_t storeAddress;
ReturnValue_t result = ReturnValue_t result =
IPCStore->addData(&storeAddress, RawCommand.getCommand(), RawCommand.getCommandSize()); ipcStore->addData(&storeAddress, RawCommand.getCommand(), RawCommand.getCommandSize());
DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet, storeAddress); DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet, storeAddress);
return result; return result;
} }
@ -135,8 +135,8 @@ void Service2DeviceAccess::sendWiretappingTm(CommandMessage* reply, uint8_t subs
store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply); store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply);
const uint8_t* data = nullptr; const uint8_t* data = nullptr;
size_t size = 0; size_t size = 0;
ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size); ReturnValue_t result = ipcStore->getData(storeAddress, &data, &size);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != RETURN_OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in " sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
"handleUnrequestedReply with failure ID " "handleUnrequestedReply with failure ID "
@ -147,10 +147,12 @@ void Service2DeviceAccess::sendWiretappingTm(CommandMessage* reply, uint8_t subs
// Init our dummy packet and correct endianness of object ID before // Init our dummy packet and correct endianness of object ID before
// sending it back. // sending it back.
WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply), data); WiretappingPacket tmPacket(DeviceHandlerMessage::getDeviceObjectId(reply), data);
TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId); result = sendTmPacket(subservice, tmPacket.objectId, tmPacket.data, size);
sendTmPacket(subservice, TmPacket.data, size, reinterpret_cast<uint8_t*>(&TmPacket.objectId), if (result != RETURN_OK) {
sizeof(TmPacket.objectId)); // TODO: Warning
return;
}
} }
MessageQueueId_t Service2DeviceAccess::getDeviceQueue() { return commandQueue->getId(); } MessageQueueId_t Service2DeviceAccess::getDeviceQueue() { return commandQueue->getId(); }

View File

@ -294,14 +294,13 @@ ReturnValue_t Service3Housekeeping::generateHkReply(const CommandMessage* hkMess
store_address_t storeId; store_address_t storeId;
sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId); sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId);
auto resultPair = IPCStore->getData(storeId); auto resultPair = ipcStore->getData(storeId);
if (resultPair.first != HasReturnvaluesIF::RETURN_OK) { if (resultPair.first != HasReturnvaluesIF::RETURN_OK) {
return resultPair.first; return resultPair.first;
} }
HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size()); HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size());
return sendTmPacket(static_cast<uint8_t>(subserviceId), hkPacket.hkData, hkPacket.hkSize, nullptr, return sendTmPacket(static_cast<uint8_t>(subserviceId), hkPacket.hkData, hkPacket.hkSize);
0);
} }
sid_t Service3Housekeeping::buildSid(object_id_t objectId, const uint8_t** tcData, sid_t Service3Housekeeping::buildSid(object_id_t objectId, const uint8_t** tcData,

View File

@ -5,14 +5,15 @@
#include "fsfw/objectmanager/ObjectManager.h" #include "fsfw/objectmanager/ObjectManager.h"
#include "fsfw/pus/servicepackets/Service5Packets.h" #include "fsfw/pus/servicepackets/Service5Packets.h"
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/tmtcpacket/pus/tm/TmPacketStored.h" #include "fsfw/tmtcservices/tmHelpers.h"
Service5EventReporting::Service5EventReporting(object_id_t objectId, uint16_t apid, Service5EventReporting::Service5EventReporting(PsbParams params, size_t maxNumberReportsPerCycle,
uint8_t serviceId, size_t maxNumberReportsPerCycle,
uint32_t messageQueueDepth) uint32_t messageQueueDepth)
: PusServiceBase(objectId, apid, serviceId), : PusServiceBase(params),
storeHelper(params.apid),
tmHelper(params.serviceId, storeHelper, sendHelper),
maxNumberReportsPerCycle(maxNumberReportsPerCycle) { maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
auto mqArgs = MqArgs(objectId, static_cast<void*>(this)); auto mqArgs = MqArgs(getObjectId(), static_cast<void*>(this));
eventQueue = QueueFactory::instance()->createMessageQueue( eventQueue = QueueFactory::instance()->createMessageQueue(
messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs); messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
} }
@ -44,15 +45,9 @@ ReturnValue_t Service5EventReporting::performService() {
ReturnValue_t Service5EventReporting::generateEventReport(EventMessage message) { ReturnValue_t Service5EventReporting::generateEventReport(EventMessage message) {
EventReport report(message.getEventId(), message.getReporter(), message.getParameter1(), EventReport report(message.getEventId(), message.getReporter(), message.getParameter1(),
message.getParameter2()); message.getParameter2());
#if FSFW_USE_PUS_C_TELEMETRY == 0 storeHelper.preparePacket(psbParams.serviceId, message.getSeverity(), tmHelper.sendCounter);
TmPacketStoredPusA tmPacket(PusServiceBase::apid, PusServiceBase::serviceId, storeHelper.setSourceDataSerializable(report);
message.getSeverity(), packetSubCounter++, &report); ReturnValue_t result = tmHelper.storeAndSendTmPacket();
#else
TmPacketStoredPusC tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
message.getSeverity(), packetSubCounter++, &report);
#endif
ReturnValue_t result =
tmPacket.sendPacket(requestQueue->getDefaultDestination(), requestQueue->getId());
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "Service5EventReporting::generateEventReport: " sif::warning << "Service5EventReporting::generateEventReport: "
@ -85,14 +80,19 @@ ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
// In addition to the default PUSServiceBase initialization, this service needs // In addition to the default PUSServiceBase initialization, this service needs
// to be registered to the event manager to listen for events. // to be registered to the event manager to listen for events.
ReturnValue_t Service5EventReporting::initialize() { ReturnValue_t Service5EventReporting::initialize() {
ReturnValue_t result = PusServiceBase::initialize();
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
auto* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER); auto* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
if (manager == nullptr) { if (manager == nullptr) {
return RETURN_FAILED; return RETURN_FAILED;
} }
// register Service 5 as listener for events // register Service 5 as listener for events
ReturnValue_t result = manager->registerListener(eventQueue->getId(), true); result = manager->registerListener(eventQueue->getId(), true);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return PusServiceBase::initialize(); initializeTmHelpers(sendHelper, storeHelper);
return result;
} }

View File

@ -3,6 +3,7 @@
#include "fsfw/events/EventMessage.h" #include "fsfw/events/EventMessage.h"
#include "fsfw/tmtcservices/PusServiceBase.h" #include "fsfw/tmtcservices/PusServiceBase.h"
#include "fsfw/tmtcservices/TmStoreAndSendHelper.h"
/** /**
* @brief Report on-board events like information or errors * @brief Report on-board events like information or errors
@ -40,9 +41,9 @@
*/ */
class Service5EventReporting : public PusServiceBase { class Service5EventReporting : public PusServiceBase {
public: public:
Service5EventReporting(object_id_t objectId, uint16_t apid, uint8_t serviceId, Service5EventReporting(PsbParams params, size_t maxNumberReportsPerCycle = 10,
size_t maxNumberReportsPerCycle, uint32_t messageQueueDepth); uint32_t messageQueueDepth = 10);
virtual ~Service5EventReporting(); ~Service5EventReporting() override;
/*** /***
* Check for events and generate event reports if required. * Check for events and generate event reports if required.
@ -74,9 +75,11 @@ class Service5EventReporting : public PusServiceBase {
}; };
private: private:
uint16_t packetSubCounter = 0;
MessageQueueIF* eventQueue = nullptr; MessageQueueIF* eventQueue = nullptr;
bool enableEventReport = true; bool enableEventReport = true;
TmSendHelper sendHelper;
TmStoreHelper storeHelper;
TmStoreAndSendWrapper tmHelper;
const uint8_t maxNumberReportsPerCycle; const uint8_t maxNumberReportsPerCycle;
ReturnValue_t generateEventReport(EventMessage message); ReturnValue_t generateEventReport(EventMessage message);

View File

@ -78,7 +78,7 @@ ReturnValue_t Service8FunctionManagement::prepareDirectCommand(CommandMessage* m
// store additional parameters into the IPC Store // store additional parameters into the IPC Store
store_address_t parameterAddress; store_address_t parameterAddress;
ReturnValue_t result = ReturnValue_t result =
IPCStore->addData(&parameterAddress, command.getParameters(), command.getParametersSize()); ipcStore->addData(&parameterAddress, command.getParameters(), command.getParametersSize());
// setCommand expects a Command Message, an Action ID and a store adress // setCommand expects a Command Message, an Action ID and a store adress
// pointing to additional parameters // pointing to additional parameters
@ -130,7 +130,7 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(const CommandMessage*
store_address_t storeId = ActionMessage::getStoreId(reply); store_address_t storeId = ActionMessage::getStoreId(reply);
size_t size = 0; size_t size = 0;
const uint8_t* buffer = nullptr; const uint8_t* buffer = nullptr;
ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size); ReturnValue_t result = ipcStore->getData(storeId, &buffer, &size);
if (result != RETURN_OK) { if (result != RETURN_OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "Service 8: Could not retrieve data for data reply" << std::endl; sif::error << "Service 8: Could not retrieve data for data reply" << std::endl;
@ -138,9 +138,9 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(const CommandMessage*
return result; return result;
} }
DataReply dataReply(objectId, actionId, buffer, size); DataReply dataReply(objectId, actionId, buffer, size);
result = sendTmPacket(static_cast<uint8_t>(Subservice::REPLY_DIRECT_COMMANDING_DATA), &dataReply); result = sendTmPacket(static_cast<uint8_t>(Subservice::REPLY_DIRECT_COMMANDING_DATA), dataReply);
auto deletionResult = IPCStore->deleteData(storeId); auto deletionResult = ipcStore->deleteData(storeId);
if (deletionResult != HasReturnvaluesIF::RETURN_OK) { if (deletionResult != HasReturnvaluesIF::RETURN_OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "Service8FunctionManagement::handleReply: Deletion" sif::warning << "Service8FunctionManagement::handleReply: Deletion"

View File

@ -32,7 +32,7 @@ class Service8FunctionManagement : public CommandingServiceBase {
public: public:
Service8FunctionManagement(object_id_t objectId, uint16_t apid, uint8_t serviceId, Service8FunctionManagement(object_id_t objectId, uint16_t apid, uint8_t serviceId,
uint8_t numParallelCommands = 4, uint16_t commandTimeoutSeconds = 60); uint8_t numParallelCommands = 4, uint16_t commandTimeoutSeconds = 60);
virtual ~Service8FunctionManagement(); ~Service8FunctionManagement() override;
protected: protected:
/* CSB abstract functions implementation . See CSB documentation. */ /* CSB abstract functions implementation . See CSB documentation. */

View File

@ -5,11 +5,9 @@
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/timemanager/CCSDSTime.h" #include "fsfw/timemanager/CCSDSTime.h"
Service9TimeManagement::Service9TimeManagement(object_id_t objectId, uint16_t apid, Service9TimeManagement::Service9TimeManagement(PsbParams params) : PusServiceBase(params) {}
uint8_t serviceId)
: PusServiceBase(objectId, apid, serviceId) {}
Service9TimeManagement::~Service9TimeManagement() {} Service9TimeManagement::~Service9TimeManagement() = default;
ReturnValue_t Service9TimeManagement::performService() { return RETURN_OK; } ReturnValue_t Service9TimeManagement::performService() { return RETURN_OK; }
@ -25,7 +23,7 @@ ReturnValue_t Service9TimeManagement::handleRequest(uint8_t subservice) {
ReturnValue_t Service9TimeManagement::setTime() { ReturnValue_t Service9TimeManagement::setTime() {
Clock::TimeOfDay_t timeToSet; Clock::TimeOfDay_t timeToSet;
TimePacket timePacket(currentPacket.getApplicationData(), currentPacket.getApplicationDataSize()); TimePacket timePacket(currentPacket.getUserData(), currentPacket.getUserDataLen());
ReturnValue_t result = ReturnValue_t result =
CCSDSTime::convertFromCcsds(&timeToSet, timePacket.getTime(), timePacket.getTimeSize()); CCSDSTime::convertFromCcsds(&timeToSet, timePacket.getTime(), timePacket.getTimeSize());
if (result != RETURN_OK) { if (result != RETURN_OK) {

View File

@ -16,16 +16,16 @@ class Service9TimeManagement : public PusServiceBase {
/** /**
* @brief This service provides the capability to set the on-board time. * @brief This service provides the capability to set the on-board time.
*/ */
Service9TimeManagement(object_id_t objectId, uint16_t apid, uint8_t serviceId); explicit Service9TimeManagement(PsbParams params);
virtual ~Service9TimeManagement(); ~Service9TimeManagement() override;
virtual ReturnValue_t performService() override; ReturnValue_t performService() override;
/** /**
* @brief Sets the onboard-time by retrieving the time to set from TC[9,128]. * @brief Sets the onboard-time by retrieving the time to set from TC[9,128].
*/ */
virtual ReturnValue_t handleRequest(uint8_t subservice) override; ReturnValue_t handleRequest(uint8_t subservice) override;
virtual ReturnValue_t setTime(); virtual ReturnValue_t setTime();

View File

@ -50,7 +50,7 @@ class FailureReport : public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
if (failureSubtype == tc_verification::PROGRESS_FAILURE) { if (failureSubtype == tcverif::PROGRESS_FAILURE) {
result = SerializeAdapter::serialize(&stepNumber, buffer, size, maxSize, streamEndianness); result = SerializeAdapter::serialize(&stepNumber, buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
@ -73,7 +73,7 @@ class FailureReport : public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6
size_t size = 0; size_t size = 0;
size += SerializeAdapter::getSerializedSize(&packetId); size += SerializeAdapter::getSerializedSize(&packetId);
size += sizeof(packetSequenceControl); size += sizeof(packetSequenceControl);
if (failureSubtype == tc_verification::PROGRESS_FAILURE) { if (failureSubtype == tcverif::PROGRESS_FAILURE) {
size += SerializeAdapter::getSerializedSize(&stepNumber); size += SerializeAdapter::getSerializedSize(&stepNumber);
} }
size += SerializeAdapter::getSerializedSize(&errorCode); size += SerializeAdapter::getSerializedSize(&errorCode);
@ -130,7 +130,7 @@ class SuccessReport : public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
if (subtype == tc_verification::PROGRESS_SUCCESS) { if (subtype == tcverif::PROGRESS_SUCCESS) {
result = SerializeAdapter::serialize(&stepNumber, buffer, size, maxSize, streamEndianness); result = SerializeAdapter::serialize(&stepNumber, buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
@ -143,7 +143,7 @@ class SuccessReport : public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5
size_t size = 0; size_t size = 0;
size += SerializeAdapter::getSerializedSize(&packetId); size += SerializeAdapter::getSerializedSize(&packetId);
size += sizeof(packetSequenceControl); size += sizeof(packetSequenceControl);
if (subtype == tc_verification::PROGRESS_SUCCESS) { if (subtype == tcverif::PROGRESS_SUCCESS) {
size += SerializeAdapter::getSerializedSize(&stepNumber); size += SerializeAdapter::getSerializedSize(&stepNumber);
} }
return size; return size;

View File

@ -1,7 +1,7 @@
#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_ #ifndef FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_
#define FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_ #define FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_
#include "../../serialize/SerialLinkedListAdapter.h" #include "fsfw/serialize/SerialLinkedListAdapter.h"
/** /**
* @brief Subservice 128 * @brief Subservice 128
@ -11,16 +11,16 @@
*/ */
class TimePacket : SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128 class TimePacket : SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
public: public:
TimePacket(const TimePacket& command) = delete;
TimePacket(const uint8_t* timeBuffer_, uint32_t timeSize_) { TimePacket(const uint8_t* timeBuffer_, uint32_t timeSize_) {
timeBuffer = timeBuffer_; timeBuffer = timeBuffer_;
timeSize = timeSize_; timeSize = timeSize_;
} }
const uint8_t* getTime() { return timeBuffer; } const uint8_t* getTime() { return timeBuffer; }
uint32_t getTimeSize() const { return timeSize; } [[nodiscard]] uint32_t getTimeSize() const { return timeSize; }
private: private:
TimePacket(const TimePacket& command);
const uint8_t* timeBuffer; const uint8_t* timeBuffer;
uint32_t timeSize; //!< [EXPORT] : [IGNORE] uint32_t timeSize; //!< [EXPORT] : [IGNORE]
}; };

View File

@ -34,9 +34,10 @@ enum : uint8_t {
FIFO_CLASS, // FF FIFO_CLASS, // FF
MESSAGE_PROXY, // MQP MESSAGE_PROXY, // MQP
TRIPLE_REDUNDACY_CHECK, // TRC TRIPLE_REDUNDACY_CHECK, // TRC
TC_PACKET_CHECK, // TCC PACKET_CHECK, // TCC
PACKET_DISTRIBUTION, // TCD PACKET_DISTRIBUTION, // TCD
ACCEPTS_TELECOMMANDS_IF, // PUS ACCEPTS_TELECOMMANDS_IF, // ATC
PUS_IF, // PUS
DEVICE_SERVICE_BASE, // DSB DEVICE_SERVICE_BASE, // DSB
COMMAND_SERVICE_BASE, // CSB COMMAND_SERVICE_BASE, // CSB
TM_STORE_BACKEND_IF, // TMB TM_STORE_BACKEND_IF, // TMB

View File

@ -10,11 +10,21 @@
#define MAKE_RETURN_CODE(number) ((INTERFACE_ID << 8) + (number)) #define MAKE_RETURN_CODE(number) ((INTERFACE_ID << 8) + (number))
typedef uint16_t ReturnValue_t; typedef uint16_t ReturnValue_t;
namespace result {
static constexpr ReturnValue_t OK = 0;
static constexpr ReturnValue_t FAILED = 1;
static constexpr ReturnValue_t makeCode(uint8_t classId, uint8_t number) {
return (static_cast<ReturnValue_t>(classId) << 8) + number;
}
} // namespace result
class HasReturnvaluesIF { class HasReturnvaluesIF {
public: public:
static const ReturnValue_t RETURN_OK = 0; static const ReturnValue_t RETURN_OK = result::OK;
static const ReturnValue_t RETURN_FAILED = 1; static const ReturnValue_t RETURN_FAILED = result::FAILED;
virtual ~HasReturnvaluesIF() {}
virtual ~HasReturnvaluesIF() = default;
/** /**
* It is discouraged to use the input parameters 0,0 and 0,1 as this * It is discouraged to use the input parameters 0,0 and 0,1 as this
@ -24,7 +34,7 @@ class HasReturnvaluesIF {
* @return * @return
*/ */
static constexpr ReturnValue_t makeReturnCode(uint8_t classId, uint8_t number) { static constexpr ReturnValue_t makeReturnCode(uint8_t classId, uint8_t number) {
return (static_cast<ReturnValue_t>(classId) << 8) + number; return result::makeCode(classId, number);
} }
}; };

6
src/fsfw/retval.h Normal file
View File

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

View File

@ -1,10 +1,10 @@
#ifndef FSFW_INC_FSFW_SERIALIZE_H_ #ifndef FSFW_SERIALIZE_H_
#define FSFW_INC_FSFW_SERIALIZE_H_ #define FSFW_SERIALIZE_H_
#include "fsfw/serialize/EndianConverter.h" #include "serialize/EndianConverter.h"
#include "fsfw/serialize/SerialArrayListAdapter.h" #include "serialize/SerialArrayListAdapter.h"
#include "fsfw/serialize/SerialBufferAdapter.h" #include "serialize/SerialBufferAdapter.h"
#include "fsfw/serialize/SerialLinkedListAdapter.h" #include "serialize/SerialLinkedListAdapter.h"
#include "fsfw/serialize/SerializeElement.h" #include "serialize/SerializeElement.h"
#endif /* FSFW_INC_FSFW_SERIALIZE_H_ */ #endif /* FSFW_SERIALIZE_H_ */

View File

@ -74,7 +74,7 @@ class SerializeAdapter {
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter; InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
uint8_t **tempPtr = const_cast<uint8_t **>(&buffer); auto **tempPtr = const_cast<uint8_t **>(&buffer);
size_t tmpSize = 0; size_t tmpSize = 0;
ReturnValue_t result = adapter.serialize(object, tempPtr, &tmpSize, maxSize, streamEndianness); ReturnValue_t result = adapter.serialize(object, tempPtr, &tmpSize, maxSize, streamEndianness);
if (serSize != nullptr) { if (serSize != nullptr) {
@ -232,7 +232,7 @@ class SerializeAdapter {
} }
} }
uint32_t getSerializedSize(const T *object) { return sizeof(T); } uint32_t getSerializedSize(const T *) { return sizeof(T); }
}; };
/** /**

View File

@ -194,8 +194,6 @@ void LocalPool::clearStore() {
for (auto& size : sizeList) { for (auto& size : sizeList) {
size = STORAGE_FREE; size = STORAGE_FREE;
} }
// std::memset(sizeList[index], 0xff,
// numberOfElements[index] * sizeof(size_type));
} }
} }
@ -338,3 +336,16 @@ void LocalPool::clearSubPool(max_subpools_t subpoolIndex) {
} }
LocalPool::max_subpools_t LocalPool::getNumberOfSubPools() const { return NUMBER_OF_SUBPOOLS; } LocalPool::max_subpools_t LocalPool::getNumberOfSubPools() const { return NUMBER_OF_SUBPOOLS; }
bool LocalPool::hasDataAtId(store_address_t storeId) const {
if (storeId.poolIndex >= NUMBER_OF_SUBPOOLS) {
return false;
}
if ((storeId.packetIndex >= numberOfElements[storeId.poolIndex])) {
return false;
}
if (sizeLists[storeId.poolIndex][storeId.packetIndex] != STORAGE_FREE) {
return true;
}
return false;
}

View File

@ -81,7 +81,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
/** /**
* @brief In the LocalPool's destructor all allocated memory is freed. * @brief In the LocalPool's destructor all allocated memory is freed.
*/ */
virtual ~LocalPool(void); ~LocalPool() override;
/** /**
* Documentation: See StorageManagerIF.h * Documentation: See StorageManagerIF.h
@ -132,6 +132,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
* @return * @return
*/ */
max_subpools_t getNumberOfSubPools() const override; max_subpools_t getNumberOfSubPools() const override;
bool hasDataAtId(store_address_t storeId) const override;
protected: protected:
/** /**

View File

@ -7,7 +7,7 @@ PoolManager::PoolManager(object_id_t setObjectId, const LocalPoolConfig& localPo
mutex = MutexFactory::instance()->createMutex(); mutex = MutexFactory::instance()->createMutex();
} }
PoolManager::~PoolManager(void) { MutexFactory::instance()->deleteMutex(mutex); } PoolManager::~PoolManager() { MutexFactory::instance()->deleteMutex(mutex); }
ReturnValue_t PoolManager::reserveSpace(const size_t size, store_address_t* address, ReturnValue_t PoolManager::reserveSpace(const size_t size, store_address_t* address,
bool ignoreFault) { bool ignoreFault) {
@ -17,7 +17,7 @@ ReturnValue_t PoolManager::reserveSpace(const size_t size, store_address_t* addr
} }
ReturnValue_t PoolManager::deleteData(store_address_t storeId) { ReturnValue_t PoolManager::deleteData(store_address_t storeId) {
#if FSFW_VERBOSE_LEVEL >= 2 #if FSFW_VERBOSE_LEVEL >= 2 && FSFW_OBJ_EVENT_TRANSLATION == 1
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::debug << "PoolManager( " << translateObject(getObjectId()) << " )::deleteData from store " sif::debug << "PoolManager( " << translateObject(getObjectId()) << " )::deleteData from store "
<< storeId.poolIndex << ". id is " << storeId.packetIndex << std::endl; << storeId.poolIndex << ". id is " << storeId.packetIndex << std::endl;

View File

@ -55,7 +55,7 @@ class StorageManagerIF : public HasReturnvaluesIF {
/** /**
* @brief This is the empty virtual destructor as required for C++ interfaces. * @brief This is the empty virtual destructor as required for C++ interfaces.
*/ */
virtual ~StorageManagerIF(){}; ~StorageManagerIF() override = default;
/** /**
* @brief With addData, a free storage position is allocated and data * @brief With addData, a free storage position is allocated and data
* stored there. * stored there.
@ -160,8 +160,10 @@ class StorageManagerIF : public HasReturnvaluesIF {
* @li RETURN_FAILED if data could not be added. * @li RETURN_FAILED if data could not be added.
* storageId is unchanged then. * storageId is unchanged then.
*/ */
virtual ReturnValue_t getFreeElement(store_address_t* storageId, const size_t size, virtual ReturnValue_t getFreeElement(store_address_t* storageId, size_t size, uint8_t** p_data,
uint8_t** p_data, bool ignoreFault = false) = 0; bool ignoreFault = false) = 0;
[[nodiscard]] virtual bool hasDataAtId(store_address_t storeId) const = 0;
/** /**
* Clears the whole store. * Clears the whole store.
@ -192,7 +194,7 @@ class StorageManagerIF : public HasReturnvaluesIF {
* Get number of pools. * Get number of pools.
* @return * @return
*/ */
virtual max_subpools_t getNumberOfSubPools() const = 0; [[nodiscard]] virtual max_subpools_t getNumberOfSubPools() const = 0;
}; };
#endif /* FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_ */ #endif /* FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_ */

View File

@ -3,26 +3,26 @@
#include <cstdint> #include <cstdint>
namespace storeId {
static constexpr uint32_t INVALID_STORE_ADDRESS = 0xffffffff;
}
/** /**
* This union defines the type that identifies where a data packet is * This union defines the type that identifies where a data packet is
* stored in the store. It comprises of a raw part to read it as raw value and * stored in the store. It comprises of a raw part to read it as raw value and
* a structured part to use it in pool-like stores. * a structured part to use it in pool-like stores.
*/ */
union store_address_t { union store_address_t {
public:
static constexpr uint32_t INVALID_RAW = 0xffffffff;
/** /**
* Default Constructor, initializing to INVALID_ADDRESS * Default Constructor, initializing to INVALID_ADDRESS
*/ */
store_address_t() : raw(storeId::INVALID_STORE_ADDRESS) {} store_address_t() : raw(INVALID_RAW) {}
/** /**
* Constructor to create an address object using the raw address * Constructor to create an address object using the raw address
* *
* @param rawAddress * @param rawAddress
*/ */
store_address_t(uint32_t rawAddress) : raw(rawAddress) {} explicit store_address_t(uint32_t rawAddress) : raw(rawAddress) {}
static store_address_t invalid() { return {}; };
/** /**
* Constructor to create an address object using pool * Constructor to create an address object using pool
@ -52,6 +52,12 @@ union store_address_t {
uint32_t raw; uint32_t raw;
bool operator==(const store_address_t& other) const { return raw == other.raw; } bool operator==(const store_address_t& other) const { return raw == other.raw; }
bool operator!=(const store_address_t& other) const { return raw != other.raw; }
store_address_t& operator=(const uint32_t rawAddr) {
raw = rawAddr;
return *this;
}
}; };
#endif /* FSFW_STORAGEMANAGER_STOREADDRESS_H_ */ #endif /* FSFW_STORAGEMANAGER_STOREADDRESS_H_ */

View File

@ -15,7 +15,7 @@ class FixedTimeslotTaskIF : public PeriodicTaskIF {
~FixedTimeslotTaskIF() override = default; ~FixedTimeslotTaskIF() override = default;
static constexpr ReturnValue_t SLOT_LIST_EMPTY = static constexpr ReturnValue_t SLOT_LIST_EMPTY =
HasReturnvaluesIF::makeReturnCode(CLASS_ID::FIXED_SLOT_TASK_IF, 0); result::makeCode(CLASS_ID::FIXED_SLOT_TASK_IF, 0);
/** /**
* Add an object with a slot time and the execution step to the task. * Add an object with a slot time and the execution step to the task.

View File

@ -2,12 +2,13 @@
#include "fsfw/objectmanager/ObjectManager.h" #include "fsfw/objectmanager/ObjectManager.h"
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/tmtcpacket/SpacePacketBase.h" #include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
#define CCSDS_DISTRIBUTOR_DEBUGGING 0 #define CCSDS_DISTRIBUTOR_DEBUGGING 0
CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId) CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId,
: TcDistributor(setObjectId), defaultApid(setDefaultApid) {} CcsdsPacketCheckIF* packetChecker)
: TcDistributor(setObjectId), defaultApid(setDefaultApid), packetChecker(packetChecker) {}
CCSDSDistributor::~CCSDSDistributor() = default; CCSDSDistributor::~CCSDSDistributor() = default;
@ -25,7 +26,7 @@ TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
#endif #endif
const uint8_t* packet = nullptr; const uint8_t* packet = nullptr;
size_t size = 0; size_t size = 0;
ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(), &packet, &size); ReturnValue_t result = tcStore->getData(currentMessage.getStorageId(), &packet, &size);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
#if FSFW_VERBOSE_LEVEL >= 1 #if FSFW_VERBOSE_LEVEL >= 1
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
@ -40,19 +41,21 @@ TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
#endif #endif
return queueMap.end(); return queueMap.end();
} }
SpacePacketBase currentPacket(packet); SpacePacketReader currentPacket(packet, size);
result = packetChecker->checkPacket(currentPacket, size);
if (result != HasReturnvaluesIF::RETURN_OK) {
}
#if FSFW_CPP_OSTREAM_ENABLED == 1 && CCSDS_DISTRIBUTOR_DEBUGGING == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1 && CCSDS_DISTRIBUTOR_DEBUGGING == 1
sif::info << "CCSDSDistributor::selectDestination has packet with APID " << std::hex sif::info << "CCSDSDistributor::selectDestination has packet with APID 0x" << std::hex
<< currentPacket.getAPID() << std::dec << std::endl; << currentPacket.getApid() << std::dec << std::endl;
#endif #endif
auto position = this->queueMap.find(currentPacket.getAPID()); auto position = this->queueMap.find(currentPacket.getApid());
if (position != this->queueMap.end()) { if (position != this->queueMap.end()) {
return position; return position;
} else { } else {
// The APID was not found. Forward packet to main SW-APID anyway to // The APID was not found. Forward packet to main SW-APID anyway to
// create acceptance failure report. // create acceptance failure report.
return this->queueMap.find(this->defaultApid); return queueMap.find(this->defaultApid);
} }
} }
@ -80,6 +83,9 @@ ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid, MessageQueueI
uint16_t CCSDSDistributor::getIdentifier() { return 0; } uint16_t CCSDSDistributor::getIdentifier() { return 0; }
ReturnValue_t CCSDSDistributor::initialize() { ReturnValue_t CCSDSDistributor::initialize() {
if (packetChecker == nullptr) {
packetChecker = new CcsdsPacketChecker(ccsds::PacketType::TC);
}
ReturnValue_t status = this->TcDistributor::initialize(); ReturnValue_t status = this->TcDistributor::initialize();
this->tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE); this->tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
if (this->tcStore == nullptr) { if (this->tcStore == nullptr) {

View File

@ -1,11 +1,12 @@
#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ #ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ #define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
#include "../objectmanager/ObjectManagerIF.h" #include "fsfw/objectmanager/ObjectManagerIF.h"
#include "../storagemanager/StorageManagerIF.h" #include "fsfw/storagemanager/StorageManagerIF.h"
#include "../tcdistribution/CCSDSDistributorIF.h" #include "fsfw/tcdistribution/CCSDSDistributorIF.h"
#include "../tcdistribution/TcDistributor.h" #include "fsfw/tcdistribution/CcsdsPacketChecker.h"
#include "../tmtcservices/AcceptsTelecommandsIF.h" #include "fsfw/tcdistribution/TcDistributor.h"
#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
/** /**
* @brief An instantiation of the CCSDSDistributorIF. * @brief An instantiation of the CCSDSDistributorIF.
@ -24,14 +25,15 @@ class CCSDSDistributor : public TcDistributor,
* TcDistributor ctor with a certain object id. * TcDistributor ctor with a certain object id.
* @details * @details
* @c tcStore is set in the @c initialize method. * @c tcStore is set in the @c initialize method.
* @param setDefaultApid The default APID, where packets with unknown * @param unknownApid The default APID, where packets with unknown
* destination are sent to. * destination are sent to.
*/ */
CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId); CCSDSDistributor(uint16_t unknownApid, object_id_t setObjectId,
CcsdsPacketCheckIF* packetChecker = nullptr);
/** /**
* The destructor is empty. * The destructor is empty.
*/ */
virtual ~CCSDSDistributor(); ~CCSDSDistributor() override;
MessageQueueId_t getRequestQueue() override; MessageQueueId_t getRequestQueue() override;
ReturnValue_t registerApplication(uint16_t apid, MessageQueueId_t id) override; ReturnValue_t registerApplication(uint16_t apid, MessageQueueId_t id) override;
@ -63,6 +65,8 @@ class CCSDSDistributor : public TcDistributor,
* pure Space Packets and there exists no SpacePacketStored class. * pure Space Packets and there exists no SpacePacketStored class.
*/ */
StorageManagerIF* tcStore = nullptr; StorageManagerIF* tcStore = nullptr;
CcsdsPacketCheckIF* packetChecker = nullptr;
}; };
#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */ #endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */

View File

@ -34,7 +34,7 @@ class CCSDSDistributorIF {
/** /**
* The empty virtual destructor. * The empty virtual destructor.
*/ */
virtual ~CCSDSDistributorIF() {} virtual ~CCSDSDistributorIF() = default;
}; };
#endif /* FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_ */ #endif /* FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_ */

View File

@ -2,7 +2,7 @@
#include "fsfw/objectmanager/ObjectManager.h" #include "fsfw/objectmanager/ObjectManager.h"
#include "fsfw/tcdistribution/CCSDSDistributorIF.h" #include "fsfw/tcdistribution/CCSDSDistributorIF.h"
#include "fsfw/tmtcpacket/cfdp/CFDPPacketStored.h" #include "fsfw/tmtcpacket/cfdp/CfdpPacketStored.h"
#ifndef FSFW_CFDP_DISTRIBUTOR_DEBUGGING #ifndef FSFW_CFDP_DISTRIBUTOR_DEBUGGING
#define FSFW_CFDP_DISTRIBUTOR_DEBUGGING 1 #define FSFW_CFDP_DISTRIBUTOR_DEBUGGING 1
@ -16,7 +16,7 @@ CFDPDistributor::CFDPDistributor(uint16_t setApid, object_id_t setObjectId,
tcStatus(RETURN_FAILED), tcStatus(RETURN_FAILED),
packetSource(setPacketSource) {} packetSource(setPacketSource) {}
CFDPDistributor::~CFDPDistributor() {} CFDPDistributor::~CFDPDistributor() = default;
CFDPDistributor::TcMqMapIter CFDPDistributor::selectDestination() { CFDPDistributor::TcMqMapIter CFDPDistributor::selectDestination() {
#if FSFW_CFDP_DISTRIBUTOR_DEBUGGING == 1 #if FSFW_CFDP_DISTRIBUTOR_DEBUGGING == 1
@ -29,13 +29,13 @@ CFDPDistributor::TcMqMapIter CFDPDistributor::selectDestination() {
storeId.packetIndex); storeId.packetIndex);
#endif #endif
#endif #endif
TcMqMapIter queueMapIt = this->queueMap.end(); auto queueMapIt = this->queueMap.end();
if (this->currentPacket == nullptr) { if (this->currentPacket == nullptr) {
return queueMapIt; return queueMapIt;
} }
this->currentPacket->setStoreAddress(this->currentMessage.getStorageId()); this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
if (currentPacket->getWholeData() != nullptr) { if (currentPacket->getFullData() != nullptr) {
tcStatus = checker.checkPacket(currentPacket); tcStatus = checker.checkPacket(*currentPacket, currentPacket->getFullPacketLen());
if (tcStatus != HasReturnvaluesIF::RETURN_OK) { if (tcStatus != HasReturnvaluesIF::RETURN_OK) {
#if FSFW_VERBOSE_LEVEL >= 1 #if FSFW_VERBOSE_LEVEL >= 1
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
@ -72,7 +72,7 @@ CFDPDistributor::TcMqMapIter CFDPDistributor::selectDestination() {
ReturnValue_t CFDPDistributor::registerHandler(AcceptsTelecommandsIF* handler) { ReturnValue_t CFDPDistributor::registerHandler(AcceptsTelecommandsIF* handler) {
uint16_t handlerId = uint16_t handlerId =
handler->getIdentifier(); // should be 0, because CFDPHandler does not set a set a service-ID handler->getIdentifier(); // should be 0, because CfdpHandler does not set a set a service-ID
#if FSFW_CFDP_DISTRIBUTOR_DEBUGGING == 1 #if FSFW_CFDP_DISTRIBUTOR_DEBUGGING == 1
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::info << "CFDPDistributor::registerHandler: Handler ID: " << static_cast<int>(handlerId) sif::info << "CFDPDistributor::registerHandler: Handler ID: " << static_cast<int>(handlerId)
@ -121,14 +121,13 @@ MessageQueueId_t CFDPDistributor::getRequestQueue() { return tcQueue->getId(); }
uint16_t CFDPDistributor::getIdentifier() { return this->apid; } uint16_t CFDPDistributor::getIdentifier() { return this->apid; }
ReturnValue_t CFDPDistributor::initialize() { ReturnValue_t CFDPDistributor::initialize() {
currentPacket = new CFDPPacketStored(); currentPacket = new CfdpPacketStored();
if (currentPacket == nullptr) { if (currentPacket == nullptr) {
// Should not happen, memory allocation failed! // Should not happen, memory allocation failed!
return ObjectManagerIF::CHILD_INIT_FAILED; return ObjectManagerIF::CHILD_INIT_FAILED;
} }
CCSDSDistributorIF* ccsdsDistributor = auto* ccsdsDistributor = ObjectManager::instance()->get<CCSDSDistributorIF>(packetSource);
ObjectManager::instance()->get<CCSDSDistributorIF>(packetSource);
if (ccsdsDistributor == nullptr) { if (ccsdsDistributor == nullptr) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "CFDPDistributor::initialize: Packet source invalid" << std::endl; sif::error << "CFDPDistributor::initialize: Packet source invalid" << std::endl;

View File

@ -1,10 +1,10 @@
#ifndef FSFW_TCDISTRIBUTION_CFDPDISTRIBUTOR_H_ #ifndef FSFW_TCDISTRIBUTION_CFDPDISTRIBUTOR_H_
#define FSFW_TCDISTRIBUTION_CFDPDISTRIBUTOR_H_ #define FSFW_TCDISTRIBUTION_CFDPDISTRIBUTOR_H_
#include <fsfw/tcdistribution/TcPacketCheckCFDP.h> #include <fsfw/tcdistribution/CfdpPacketChecker.h>
#include "../returnvalues/HasReturnvaluesIF.h" #include "../returnvalues/HasReturnvaluesIF.h"
#include "../tmtcpacket/cfdp/CFDPPacketStored.h" #include "../tmtcpacket/cfdp/CfdpPacketStored.h"
#include "../tmtcservices/AcceptsTelecommandsIF.h" #include "../tmtcservices/AcceptsTelecommandsIF.h"
#include "../tmtcservices/VerificationReporter.h" #include "../tmtcservices/VerificationReporter.h"
#include "CFDPDistributorIF.h" #include "CFDPDistributorIF.h"
@ -31,7 +31,7 @@ class CFDPDistributor : public TcDistributor,
/** /**
* The destructor is empty. * The destructor is empty.
*/ */
virtual ~CFDPDistributor(); ~CFDPDistributor() override;
ReturnValue_t registerHandler(AcceptsTelecommandsIF* handler) override; ReturnValue_t registerHandler(AcceptsTelecommandsIF* handler) override;
MessageQueueId_t getRequestQueue() override; MessageQueueId_t getRequestQueue() override;
ReturnValue_t initialize() override; ReturnValue_t initialize() override;
@ -42,8 +42,8 @@ class CFDPDistributor : public TcDistributor,
/** /**
* The currently handled packet is stored here. * The currently handled packet is stored here.
*/ */
CFDPPacketStored* currentPacket = nullptr; CfdpPacketStored* currentPacket = nullptr;
TcPacketCheckCFDP checker; CfdpPacketChecker checker;
/** /**
* With this variable, the current check status is stored to generate * With this variable, the current check status is stored to generate
* acceptance messages later. * acceptance messages later.

View File

@ -13,7 +13,7 @@ class CFDPDistributorIF {
/** /**
* The empty virtual destructor. * The empty virtual destructor.
*/ */
virtual ~CFDPDistributorIF() {} virtual ~CFDPDistributorIF() = default;
/** /**
* With this method, Handlers can register themselves at the CFDP Distributor. * With this method, Handlers can register themselves at the CFDP Distributor.
* @param handler A pointer to the registering Handler. * @param handler A pointer to the registering Handler.

View File

@ -1,4 +1,9 @@
target_sources( target_sources(
${LIB_FSFW_NAME} ${LIB_FSFW_NAME}
PRIVATE CCSDSDistributor.cpp PUSDistributor.cpp TcDistributor.cpp PRIVATE CCSDSDistributor.cpp
TcPacketCheckPUS.cpp TcPacketCheckCFDP.cpp CFDPDistributor.cpp) PusDistributor.cpp
TcDistributor.cpp
PusPacketChecker.cpp
TcPacketCheckCFDP.cpp
CFDPDistributor.cpp
CcsdsPacketChecker.cpp)

View File

@ -1,30 +1,32 @@
#ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKIF_H_ #ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKIF_H_
#define FSFW_TCDISTRIBUTION_TCPACKETCHECKIF_H_ #define FSFW_TCDISTRIBUTION_TCPACKETCHECKIF_H_
#include "../returnvalues/HasReturnvaluesIF.h" #include <cstddef>
class SpacePacketBase; #include "fsfw/returnvalues/HasReturnvaluesIF.h"
class SpacePacketReader;
/** /**
* This interface is used by PacketCheckers for PUS packets and CFDP packets . * This interface is used by PacketCheckers for PUS packets and CFDP packets .
* @ingroup tc_distribution * @ingroup tc_distribution
*/ */
class TcPacketCheckIF { class CcsdsPacketCheckIF {
public: public:
/** /**
* The empty virtual destructor. * The empty virtual destructor.
*/ */
virtual ~TcPacketCheckIF() {} virtual ~CcsdsPacketCheckIF() = default;
/** /**
* This is the actual method to formally check a certain Packet. * This is the actual method to formally check a certain Packet.
* The packet's Application Data can not be checked here. * The packet's Application Data can not be checked here.
* @param current_packet The packet to check * @param current_packet The packet to check
* @return - @c RETURN_OK on success. * @return - @c RETURN_OK on success.
* - @c INCORRECT_CHECKSUM if checksum is invalid. * - @c INCORRECT_CHECKSUM if checksum is invalid.
* - @c ILLEGAL_APID if APID does not match. * - @c ILLEGAL_APID if APID does not match.
*/ */
virtual ReturnValue_t checkPacket(SpacePacketBase* currentPacket) = 0; virtual ReturnValue_t checkPacket(const SpacePacketReader& currentPacket, size_t packetLen) = 0;
}; };
#endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKIF_H_ */ #endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKIF_H_ */

View File

@ -0,0 +1,33 @@
#include "CcsdsPacketChecker.h"
#include "fsfw/tcdistribution/definitions.h"
#include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
CcsdsPacketChecker::CcsdsPacketChecker(ccsds::PacketType packetType_, uint8_t ccsdsVersion_)
: packetType(packetType_), ccsdsVersion(ccsdsVersion_) {}
ReturnValue_t CcsdsPacketChecker::checkPacket(const SpacePacketReader& currentPacket,
size_t packetLen) {
if (checkApid) {
if (currentPacket.getApid() != apid) {
return tcdistrib::INVALID_APID;
}
}
if (currentPacket.getVersion() != ccsdsVersion) {
return tcdistrib::INVALID_CCSDS_VERSION;
}
if (currentPacket.getPacketType() != packetType) {
return tcdistrib::INVALID_PACKET_TYPE;
}
// This assumes that the getFullPacketLen version uses the space packet data length field
if (currentPacket.getFullPacketLen() != packetLen) {
return tcdistrib::INCOMPLETE_PACKET;
}
return HasReturnvaluesIF::RETURN_OK;
}
void CcsdsPacketChecker::setApidToCheck(uint16_t apid_) {
apid = apid_;
checkApid = true;
}

View File

@ -0,0 +1,20 @@
#ifndef FSFW_TESTS_CCSDSPACKETCHECKERBASE_H
#define FSFW_TESTS_CCSDSPACKETCHECKERBASE_H
#include "CcsdsPacketCheckIF.h"
#include "fsfw/tmtcpacket/ccsds/SpacePacketIF.h"
class CcsdsPacketChecker : public CcsdsPacketCheckIF, public HasReturnvaluesIF {
public:
CcsdsPacketChecker(ccsds::PacketType packetType, uint8_t ccsdsVersion = 0b000);
void setApidToCheck(uint16_t apid);
ReturnValue_t checkPacket(const SpacePacketReader& currentPacket, size_t packetLen) override;
protected:
bool checkApid = false;
uint16_t apid = 0;
ccsds::PacketType packetType;
uint8_t ccsdsVersion;
};
#endif // FSFW_TESTS_CCSDSPACKETCHECKERBASE_H

View File

@ -1,16 +1,16 @@
#ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKCFDP_H_ #ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKCFDP_H_
#define FSFW_TCDISTRIBUTION_TCPACKETCHECKCFDP_H_ #define FSFW_TCDISTRIBUTION_TCPACKETCHECKCFDP_H_
#include "TcPacketCheckIF.h" #include "CcsdsPacketCheckIF.h"
#include "fsfw/FSFW.h" #include "fsfw/FSFW.h"
class CFDPPacketStored; class CfdpPacketStored;
/** /**
* This class performs a formal packet check for incoming CFDP Packets. * This class performs a formal packet check for incoming CFDP Packets.
* @ingroup tc_distribution * @ingroup tc_distribution
*/ */
class TcPacketCheckCFDP : public TcPacketCheckIF, public HasReturnvaluesIF { class CfdpPacketChecker : public CcsdsPacketCheckIF, public HasReturnvaluesIF {
protected: protected:
/** /**
* The packet id each correct packet should have. * The packet id each correct packet should have.
@ -23,11 +23,11 @@ class TcPacketCheckCFDP : public TcPacketCheckIF, public HasReturnvaluesIF {
* The constructor only sets the APID attribute. * The constructor only sets the APID attribute.
* @param set_apid The APID to set. * @param set_apid The APID to set.
*/ */
TcPacketCheckCFDP(uint16_t setApid); explicit CfdpPacketChecker(uint16_t setApid);
ReturnValue_t checkPacket(SpacePacketBase* currentPacket) override; ReturnValue_t checkPacket(const SpacePacketReader& currentPacket, size_t packetLen) override;
uint16_t getApid() const; [[nodiscard]] uint16_t getApid() const;
}; };
#endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKCFDP_H_ */ #endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKCFDP_H_ */

View File

@ -1,146 +0,0 @@
#include "fsfw/tcdistribution/PUSDistributor.h"
#include "fsfw/objectmanager/ObjectManager.h"
#include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/tcdistribution/CCSDSDistributorIF.h"
#include "fsfw/tmtcservices/PusVerificationReport.h"
#define PUS_DISTRIBUTOR_DEBUGGING 0
PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
object_id_t setPacketSource)
: TcDistributor(setObjectId),
checker(setApid),
verifyChannel(),
tcStatus(RETURN_FAILED),
packetSource(setPacketSource) {}
PUSDistributor::~PUSDistributor() = default;
PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
#if FSFW_CPP_OSTREAM_ENABLED == 1 && PUS_DISTRIBUTOR_DEBUGGING == 1
store_address_t storeId = this->currentMessage.getStorageId());
sif::debug << "PUSDistributor::handlePacket received: " << storeId.poolIndex << ", "
<< storeId.packetIndex << std::endl;
#endif
auto queueMapIt = this->queueMap.end();
if (this->currentPacket == nullptr) {
return queueMapIt;
}
this->currentPacket->setStoreAddress(this->currentMessage.getStorageId(), currentPacket);
if (currentPacket->getWholeData() != nullptr) {
tcStatus = checker.checkPacket(currentPacket);
if (tcStatus != HasReturnvaluesIF::RETURN_OK) {
#if FSFW_VERBOSE_LEVEL >= 1
const char* keyword = "unnamed error";
if (tcStatus == TcPacketCheckPUS::INCORRECT_CHECKSUM) {
keyword = "checksum";
} else if (tcStatus == TcPacketCheckPUS::INCORRECT_PRIMARY_HEADER) {
keyword = "incorrect primary header";
} else if (tcStatus == TcPacketCheckPUS::ILLEGAL_APID) {
keyword = "illegal APID";
} else if (tcStatus == TcPacketCheckPUS::INCORRECT_SECONDARY_HEADER) {
keyword = "incorrect secondary header";
} else if (tcStatus == TcPacketCheckPUS::INCOMPLETE_PACKET) {
keyword = "incomplete packet";
}
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "PUSDistributor::handlePacket: Packet format invalid, " << keyword
<< " error" << std::endl;
#else
sif::printWarning("PUSDistributor::handlePacket: Packet format invalid, %s error\n",
keyword);
#endif
#endif
}
uint32_t queue_id = currentPacket->getService();
queueMapIt = this->queueMap.find(queue_id);
} else {
tcStatus = PACKET_LOST;
}
if (queueMapIt == this->queueMap.end()) {
tcStatus = DESTINATION_NOT_FOUND;
#if FSFW_VERBOSE_LEVEL >= 1
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::debug << "PUSDistributor::handlePacket: Destination not found" << std::endl;
#else
sif::printDebug("PUSDistributor::handlePacket: Destination not found\n");
#endif /* !FSFW_CPP_OSTREAM_ENABLED == 1 */
#endif
}
if (tcStatus != RETURN_OK) {
return this->queueMap.end();
} else {
return queueMapIt;
}
}
ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
uint16_t serviceId = service->getIdentifier();
#if PUS_DISTRIBUTOR_DEBUGGING == 1
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::info << "Service ID: " << static_cast<int>(serviceId) << std::endl;
#else
sif::printInfo("Service ID: %d\n", static_cast<int>(serviceId));
#endif
#endif
MessageQueueId_t queue = service->getRequestQueue();
auto returnPair = queueMap.emplace(serviceId, queue);
if (not returnPair.second) {
#if FSFW_VERBOSE_LEVEL >= 1
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "PUSDistributor::registerService: Service ID already"
" exists in map"
<< std::endl;
#else
sif::printError("PUSDistributor::registerService: Service ID already exists in map\n");
#endif
#endif
return SERVICE_ID_ALREADY_EXISTS;
}
return HasReturnvaluesIF::RETURN_OK;
}
MessageQueueId_t PUSDistributor::getRequestQueue() { return tcQueue->getId(); }
ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
if (queueStatus != RETURN_OK) {
tcStatus = queueStatus;
}
if (tcStatus != RETURN_OK) {
this->verifyChannel.sendFailureReport(tc_verification::ACCEPTANCE_FAILURE, currentPacket,
tcStatus);
// A failed packet is deleted immediately after reporting,
// otherwise it will block memory.
currentPacket->deletePacket();
return RETURN_FAILED;
} else {
this->verifyChannel.sendSuccessReport(tc_verification::ACCEPTANCE_SUCCESS, currentPacket);
return RETURN_OK;
}
}
uint16_t PUSDistributor::getIdentifier() { return checker.getApid(); }
ReturnValue_t PUSDistributor::initialize() {
currentPacket = new TcPacketStoredPus();
if (currentPacket == nullptr) {
// Should not happen, memory allocation failed!
return ObjectManagerIF::CHILD_INIT_FAILED;
}
auto* ccsdsDistributor = ObjectManager::instance()->get<CCSDSDistributorIF>(packetSource);
if (ccsdsDistributor == nullptr) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "PUSDistributor::initialize: Packet source invalid" << std::endl;
sif::error << " Make sure it exists and implements CCSDSDistributorIF!" << std::endl;
#else
sif::printError("PUSDistributor::initialize: Packet source invalid\n");
sif::printError("Make sure it exists and implements CCSDSDistributorIF\n");
#endif
return RETURN_FAILED;
}
return ccsdsDistributor->registerApplication(this);
}

View File

@ -0,0 +1,169 @@
#include "fsfw/tcdistribution/PusDistributor.h"
#include "definitions.h"
#include "fsfw/objectmanager/ObjectManager.h"
#include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/tcdistribution/CCSDSDistributorIF.h"
#include "fsfw/tmtcservices/PusVerificationReport.h"
#define PUS_DISTRIBUTOR_DEBUGGING 0
PusDistributor::PusDistributor(uint16_t setApid, object_id_t setObjectId,
CCSDSDistributorIF* distributor, StorageManagerIF* store_)
: TcDistributor(setObjectId),
store(store_),
checker(setApid, ccsds::PacketType::TC),
ccsdsDistributor(distributor),
tcStatus(RETURN_FAILED) {}
PusDistributor::~PusDistributor() = default;
PusDistributor::TcMqMapIter PusDistributor::selectDestination() {
#if FSFW_CPP_OSTREAM_ENABLED == 1 && PUS_DISTRIBUTOR_DEBUGGING == 1
store_address_t storeId = currentMessage.getStorageId();
sif::debug << "PUSDistributor::handlePacket received: " << storeId.poolIndex << ", "
<< storeId.packetIndex << std::endl;
#endif
auto queueMapIt = queueMap.end();
// TODO: Need to set the data
const uint8_t* packetPtr = nullptr;
size_t packetLen = 0;
if (store->getData(currentMessage.getStorageId(), &packetPtr, &packetLen) !=
HasReturnvaluesIF::RETURN_OK) {
return queueMapIt;
}
ReturnValue_t result = reader.setReadOnlyData(packetPtr, packetLen);
if (result != HasReturnvaluesIF::RETURN_OK) {
tcStatus = PACKET_LOST;
return queueMapIt;
}
// CRC check done by checker
result = reader.parseDataWithoutCrcCheck();
if (result != HasReturnvaluesIF::RETURN_OK) {
tcStatus = PACKET_LOST;
return queueMapIt;
}
if (reader.getFullData() != nullptr) {
tcStatus = checker.checkPacket(reader, reader.getFullPacketLen());
if (tcStatus != HasReturnvaluesIF::RETURN_OK) {
checkerFailurePrinter();
}
uint32_t queue_id = reader.getService();
queueMapIt = queueMap.find(queue_id);
} else {
tcStatus = PACKET_LOST;
}
if (queueMapIt == this->queueMap.end()) {
tcStatus = DESTINATION_NOT_FOUND;
#if FSFW_VERBOSE_LEVEL >= 1
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::debug << "PUSDistributor::handlePacket: Destination not found" << std::endl;
#else
sif::printDebug("PUSDistributor::handlePacket: Destination not found\n");
#endif /* !FSFW_CPP_OSTREAM_ENABLED == 1 */
#endif
}
if (tcStatus != RETURN_OK) {
return this->queueMap.end();
} else {
return queueMapIt;
}
}
ReturnValue_t PusDistributor::registerService(AcceptsTelecommandsIF* service) {
uint16_t serviceId = service->getIdentifier();
#if PUS_DISTRIBUTOR_DEBUGGING == 1
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::info << "Service ID: " << static_cast<int>(serviceId) << std::endl;
#else
sif::printInfo("Service ID: %d\n", static_cast<int>(serviceId));
#endif
#endif
MessageQueueId_t queue = service->getRequestQueue();
auto returnPair = queueMap.emplace(serviceId, queue);
if (not returnPair.second) {
#if FSFW_VERBOSE_LEVEL >= 1
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "PUSDistributor::registerService: Service ID already"
" exists in map"
<< std::endl;
#else
sif::printError("PUSDistributor::registerService: Service ID already exists in map\n");
#endif
#endif
return SERVICE_ID_ALREADY_EXISTS;
}
return HasReturnvaluesIF::RETURN_OK;
}
MessageQueueId_t PusDistributor::getRequestQueue() { return tcQueue->getId(); }
ReturnValue_t PusDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
if (queueStatus != RETURN_OK) {
tcStatus = queueStatus;
}
if (tcStatus != RETURN_OK) {
verifyChannel->sendFailureReport(
VerifFailureParams(tcverif::ACCEPTANCE_FAILURE, reader, tcStatus));
// A failed packet is deleted immediately after reporting,
// otherwise it will block memory.
store->deleteData(currentMessage.getStorageId());
return RETURN_FAILED;
} else {
verifyChannel->sendSuccessReport(VerifSuccessParams(tcverif::ACCEPTANCE_SUCCESS, reader));
return RETURN_OK;
}
}
uint16_t PusDistributor::getIdentifier() { return checker.getApid(); }
ReturnValue_t PusDistributor::initialize() {
if (store == nullptr) {
store = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
if (store == nullptr) {
return ObjectManagerIF::CHILD_INIT_FAILED;
}
}
if (ccsdsDistributor == nullptr) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "PUSDistributor::initialize: Packet source invalid" << std::endl;
sif::error << " Make sure it exists and implements CCSDSDistributorIF!" << std::endl;
#else
sif::printError("PusDistributor::initialize: Packet source invalid\n");
sif::printError("Make sure it exists and implements CCSDSDistributorIF\n");
#endif
return ObjectManagerIF::CHILD_INIT_FAILED;
}
if (verifyChannel == nullptr) {
verifyChannel = ObjectManager::instance()->get<VerificationReporterIF>(objects::VERIFICATION_REPORTER);
if (verifyChannel == nullptr) {
return ObjectManagerIF::CHILD_INIT_FAILED;
}
}
return ccsdsDistributor->registerApplication(this);
}
void PusDistributor::checkerFailurePrinter() const {
#if FSFW_VERBOSE_LEVEL >= 1
const char* keyword = "unnamed error";
if (tcStatus == tcdistrib::INCORRECT_CHECKSUM) {
keyword = "checksum";
} else if (tcStatus == tcdistrib::INCORRECT_PRIMARY_HEADER) {
keyword = "incorrect primary header";
} else if (tcStatus == tcdistrib::INVALID_APID) {
keyword = "illegal APID";
} else if (tcStatus == tcdistrib::INCORRECT_SECONDARY_HEADER) {
keyword = "incorrect secondary header";
} else if (tcStatus == tcdistrib::INCOMPLETE_PACKET) {
keyword = "incomplete packet";
}
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "PUSDistributor::handlePacket: Packet format invalid, " << keyword << " error"
<< std::endl;
#else
sif::printWarning("PUSDistributor::handlePacket: Packet format invalid, %s error\n", keyword);
#endif
#endif
}

View File

@ -2,20 +2,22 @@
#define FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ #define FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
#include "PUSDistributorIF.h" #include "PUSDistributorIF.h"
#include "PusPacketChecker.h"
#include "TcDistributor.h" #include "TcDistributor.h"
#include "TcPacketCheckPUS.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h" #include "fsfw/returnvalues/HasReturnvaluesIF.h"
#include "fsfw/tmtcpacket/pus/tc.h" #include "fsfw/tmtcpacket/pus/tc.h"
#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h" #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
#include "fsfw/tmtcservices/VerificationReporter.h" #include "fsfw/tmtcservices/VerificationReporter.h"
class CCSDSDistributorIF;
/** /**
* This class accepts PUS Telecommands and forwards them to Application * This class accepts PUS Telecommands and forwards them to Application
* services. In addition, the class performs a formal packet check and * services. In addition, the class performs a formal packet check and
* sends acceptance success or failure messages. * sends acceptance success or failure messages.
* @ingroup tc_distribution * @ingroup tc_distribution
*/ */
class PUSDistributor : public TcDistributor, public PUSDistributorIF, public AcceptsTelecommandsIF { class PusDistributor : public TcDistributor, public PUSDistributorIF, public AcceptsTelecommandsIF {
public: public:
/** /**
* The ctor passes @c set_apid to the checker class and calls the * The ctor passes @c set_apid to the checker class and calls the
@ -25,30 +27,31 @@ class PUSDistributor : public TcDistributor, public PUSDistributorIF, public Acc
* @param setPacketSource Object ID of the source of TC packets. * @param setPacketSource Object ID of the source of TC packets.
* Must implement CCSDSDistributorIF. * Must implement CCSDSDistributorIF.
*/ */
PUSDistributor(uint16_t setApid, object_id_t setObjectId, object_id_t setPacketSource); PusDistributor(uint16_t setApid, object_id_t setObjectId, CCSDSDistributorIF* packetSource,
StorageManagerIF* store = nullptr);
/** /**
* The destructor is empty. * The destructor is empty.
*/ */
virtual ~PUSDistributor(); ~PusDistributor() override;
ReturnValue_t registerService(AcceptsTelecommandsIF* service) override; ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
MessageQueueId_t getRequestQueue() override; MessageQueueId_t getRequestQueue() override;
ReturnValue_t initialize() override; ReturnValue_t initialize() override;
uint16_t getIdentifier() override; uint16_t getIdentifier() override;
protected: protected:
StorageManagerIF* store;
/** /**
* This attribute contains the class, that performs a formal packet check. * This attribute contains the class, that performs a formal packet check.
*/ */
TcPacketCheckPUS checker; PusPacketChecker checker;
/** /**
* With this class, verification messages are sent to the * With this class, verification messages are sent to the
* TC Verification service. * TC Verification service.
*/ */
VerificationReporter verifyChannel; VerificationReporterIF* verifyChannel = nullptr;
/** //! Cached for initialization
* The currently handled packet is stored here. CCSDSDistributorIF* ccsdsDistributor = nullptr;
*/ PusTcReader reader;
TcPacketStoredPus* currentPacket = nullptr;
/** /**
* With this variable, the current check status is stored to generate * With this variable, the current check status is stored to generate
@ -56,8 +59,6 @@ class PUSDistributor : public TcDistributor, public PUSDistributorIF, public Acc
*/ */
ReturnValue_t tcStatus; ReturnValue_t tcStatus;
const object_id_t packetSource;
/** /**
* This method reads the packet service, checks if such a service is * This method reads the packet service, checks if such a service is
* registered and forwards the packet to the destination. * registered and forwards the packet to the destination.
@ -72,6 +73,8 @@ class PUSDistributor : public TcDistributor, public PUSDistributorIF, public Acc
* success/failure messages. * success/failure messages.
*/ */
ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus) override; ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus) override;
void checkerFailurePrinter() const;
}; };
#endif /* FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */ #endif /* FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */

View File

@ -0,0 +1,30 @@
#include "fsfw/tcdistribution/PusPacketChecker.h"
#include "fsfw/globalfunctions/CRC.h"
#include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/tcdistribution/definitions.h"
#include "fsfw/tmtcpacket/pus/tc/PusTcReader.h"
PusPacketChecker::PusPacketChecker(uint16_t apid, ccsds::PacketType packetType_,
ecss::PusVersion pusVersion_)
: pusVersion(pusVersion_), apid(apid) {}
ReturnValue_t PusPacketChecker::checkPacket(const PusTcReader& pusPacket, size_t packetLen) {
// Other primary header fields are checked by base class
if (not pusPacket.hasSecHeader()) {
return tcdistrib::INVALID_SEC_HEADER_FIELD;
}
uint16_t calculated_crc = CRC::crc16ccitt(pusPacket.getFullData(), pusPacket.getFullPacketLen());
if (calculated_crc != 0) {
return tcdistrib::INCORRECT_CHECKSUM;
}
if (pusPacket.getApid() != apid) {
return tcdistrib::INVALID_APID;
}
if (pusPacket.getPusVersion() != pusVersion) {
return tcdistrib::INVALID_PUS_VERSION;
}
return HasReturnvaluesIF::RETURN_OK;
}
uint16_t PusPacketChecker::getApid() const { return apid; }

View File

@ -0,0 +1,34 @@
#ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_
#define FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_
#include "fsfw/FSFW.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
#include "fsfw/tmtcpacket/pus/defs.h"
#include "fsfw/tmtcservices/PusVerificationReport.h"
/**
* This class performs a formal packet check for incoming PUS Telecommand Packets.
* Currently, it only checks if the APID and CRC are correct.
* @ingroup tc_distribution
*/
class PusPacketChecker {
public:
/**
* The constructor only sets the APID attribute.
* @param set_apid The APID to set.
*/
explicit PusPacketChecker(uint16_t apid, ccsds::PacketType packetType,
ecss::PusVersion = ecss::PusVersion::PUS_C);
ReturnValue_t checkPacket(const PusTcReader& currentPacket, size_t packetLen);
[[nodiscard]] uint16_t getApid() const;
protected:
ecss::PusVersion pusVersion;
uint16_t apid;
private:
};
#endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_ */

View File

@ -13,25 +13,24 @@ TcDistributor::TcDistributor(object_id_t objectId) : SystemObject(objectId) {
TcDistributor::~TcDistributor() { QueueFactory::instance()->deleteMessageQueue(tcQueue); } TcDistributor::~TcDistributor() { QueueFactory::instance()->deleteMessageQueue(tcQueue); }
ReturnValue_t TcDistributor::performOperation(uint8_t opCode) { ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
ReturnValue_t status = RETURN_OK; ReturnValue_t status;
for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK; for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
status = tcQueue->receiveMessage(&currentMessage)) { status = tcQueue->receiveMessage(&currentMessage)) {
status = handlePacket(); status = handlePacket();
} }
if (status == MessageQueueIF::EMPTY) { if (status == MessageQueueIF::EMPTY) {
return RETURN_OK; return RETURN_OK;
} else {
return status;
} }
return status;
} }
ReturnValue_t TcDistributor::handlePacket() { ReturnValue_t TcDistributor::handlePacket() {
TcMqMapIter queueMapIt = this->selectDestination(); auto queueMapIt = selectDestination();
ReturnValue_t returnValue = RETURN_FAILED; ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
if (queueMapIt != this->queueMap.end()) { if (queueMapIt != queueMap.end()) {
returnValue = this->tcQueue->sendMessage(queueMapIt->second, &this->currentMessage); result = tcQueue->sendMessage(queueMapIt->second, &currentMessage);
} }
return this->callbackAfterSending(returnValue); return callbackAfterSending(result);
} }
void TcDistributor::print() { void TcDistributor::print() {

View File

@ -1,9 +1,11 @@
#include "fsfw/tcdistribution/TcPacketCheckCFDP.h" #include "fsfw/tcdistribution/CfdpPacketChecker.h"
#include "fsfw/tmtcpacket/cfdp/CfdpPacketStored.h"
#include "fsfw/tmtcpacket/cfdp/CFDPPacketStored.h" CfdpPacketChecker::CfdpPacketChecker(uint16_t setApid) : apid(setApid) {}
TcPacketCheckCFDP::TcPacketCheckCFDP(uint16_t setApid) : apid(setApid) {} ReturnValue_t CfdpPacketChecker::checkPacket(const SpacePacketReader& currentPacket,
size_t packetLen) {
return RETURN_OK;
}
ReturnValue_t TcPacketCheckCFDP::checkPacket(SpacePacketBase* currentPacket) { return RETURN_OK; } uint16_t CfdpPacketChecker::getApid() const { return apid; }
uint16_t TcPacketCheckCFDP::getApid() const { return apid; }

View File

@ -1,44 +0,0 @@
#include "fsfw/tcdistribution/TcPacketCheckPUS.h"
#include "fsfw/globalfunctions/CRC.h"
#include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/storagemanager/StorageManagerIF.h"
#include "fsfw/tmtcpacket/pus/tc/TcPacketPusBase.h"
#include "fsfw/tmtcpacket/pus/tc/TcPacketStoredBase.h"
#include "fsfw/tmtcpacket/pus/tc/TcPacketStoredPus.h"
#include "fsfw/tmtcservices/VerificationCodes.h"
TcPacketCheckPUS::TcPacketCheckPUS(uint16_t setApid) : apid(setApid) {}
ReturnValue_t TcPacketCheckPUS::checkPacket(SpacePacketBase* currentPacket) {
TcPacketStoredBase* storedPacket = dynamic_cast<TcPacketStoredBase*>(currentPacket);
TcPacketPusBase* tcPacketBase = dynamic_cast<TcPacketPusBase*>(currentPacket);
if (tcPacketBase == nullptr or storedPacket == nullptr) {
return RETURN_FAILED;
}
uint16_t calculated_crc =
CRC::crc16ccitt(tcPacketBase->getWholeData(), tcPacketBase->getFullSize());
if (calculated_crc != 0) {
return INCORRECT_CHECKSUM;
}
bool condition = (not tcPacketBase->hasSecondaryHeader()) or
(tcPacketBase->getPacketVersionNumber() != CCSDS_VERSION_NUMBER) or
(not tcPacketBase->isTelecommand());
if (condition) {
return INCORRECT_PRIMARY_HEADER;
}
if (tcPacketBase->getAPID() != this->apid) return ILLEGAL_APID;
if (not storedPacket->isSizeCorrect()) {
return INCOMPLETE_PACKET;
}
condition = (tcPacketBase->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
(tcPacketBase->getPusVersionNumber() != PUS_VERSION_NUMBER);
if (condition) {
return INCORRECT_SECONDARY_HEADER;
}
return RETURN_OK;
}
uint16_t TcPacketCheckPUS::getApid() const { return apid; }

View File

@ -1,61 +0,0 @@
#ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_
#define FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_
#include "TcPacketCheckIF.h"
#include "fsfw/FSFW.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
#include "fsfw/tmtcservices/PusVerificationReport.h"
class TcPacketStoredBase;
/**
* This class performs a formal packet check for incoming PUS Telecommand Packets.
* Currently, it only checks if the APID and CRC are correct.
* @ingroup tc_distribution
*/
class TcPacketCheckPUS : public TcPacketCheckIF, public HasReturnvaluesIF {
protected:
/**
* Describes the version number a packet must have to pass.
*/
static constexpr uint8_t CCSDS_VERSION_NUMBER = 0;
/**
* Describes the secondary header a packet must have to pass.
*/
static constexpr uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
/**
* Describes the TC Packet PUS Version Number a packet must have to pass.
*/
#if FSFW_USE_PUS_C_TELECOMMANDS == 1
static constexpr uint8_t PUS_VERSION_NUMBER = 2;
#else
static constexpr uint8_t PUS_VERSION_NUMBER = 1;
#endif
/**
* The packet id each correct packet should have.
* It is composed of the APID and some static fields.
*/
uint16_t apid;
public:
static const uint8_t INTERFACE_ID = CLASS_ID::TC_PACKET_CHECK;
static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE(0);
static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE(1);
static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE(2);
static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE(3);
static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE(4);
static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE(5);
static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE(6);
/**
* The constructor only sets the APID attribute.
* @param set_apid The APID to set.
*/
TcPacketCheckPUS(uint16_t setApid);
ReturnValue_t checkPacket(SpacePacketBase* currentPacket) override;
uint16_t getApid() const;
};
#endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_ */

View File

@ -0,0 +1,24 @@
#ifndef FSFW_TMTCPACKET_DEFINITIONS_H
#define FSFW_TMTCPACKET_DEFINITIONS_H
#include <cstdint>
#include "fsfw/returnvalues/FwClassIds.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
namespace tcdistrib {
static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_CHECK;
static constexpr ReturnValue_t INVALID_CCSDS_VERSION = MAKE_RETURN_CODE(0);
static constexpr ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(1);
static constexpr ReturnValue_t INVALID_PACKET_TYPE = MAKE_RETURN_CODE(2);
static constexpr ReturnValue_t INVALID_SEC_HEADER_FIELD = MAKE_RETURN_CODE(3);
static constexpr ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE(4);
static constexpr ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE(5);
static constexpr ReturnValue_t INVALID_PUS_VERSION = MAKE_RETURN_CODE(6);
static constexpr ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE(7);
static constexpr ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE(8);
static constexpr ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE(9);
}; // namespace tcdistrib
#endif // FSFW_TMTCPACKET_DEFINITIONS_H

View File

@ -504,7 +504,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from, size_t
} else if ((pField & 0b11) == 0b10) { } else if ((pField & 0b11) == 0b10) {
expectedLength += 4; expectedLength += 4;
} }
if (foundLength != NULL) { if (foundLength != nullptr) {
*foundLength = expectedLength; *foundLength = expectedLength;
} }
if (expectedLength > maxLength) { if (expectedLength > maxLength) {

View File

@ -6,9 +6,9 @@
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include "../returnvalues/HasReturnvaluesIF.h"
#include "Clock.h" #include "Clock.h"
#include "clockDefinitions.h" #include "clockDefinitions.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
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);

View File

@ -1,3 +1,4 @@
target_sources( target_sources(
${LIB_FSFW_NAME} PRIVATE CCSDSTime.cpp Countdown.cpp Stopwatch.cpp ${LIB_FSFW_NAME}
TimeMessage.cpp TimeStamper.cpp ClockCommon.cpp) PRIVATE CCSDSTime.cpp Countdown.cpp Stopwatch.cpp TimeMessage.cpp
CdsShortTimeStamper.cpp ClockCommon.cpp)

View File

@ -0,0 +1,14 @@
#include "CcsdsTimeStampReader.h"
#include "CCSDSTime.h"
ReturnValue_t CcsdsTimestampReader::readTimeStamp(const uint8_t* buffer, uint8_t maxSize) {
ReturnValue_t result = CCSDSTime::convertFromCcsds(&time, buffer, &timestampLen, maxSize);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return result;
}
timeval& CcsdsTimestampReader::getTime() { return time; }
size_t CcsdsTimestampReader::getTimestampLen() { return timestampLen; }

View File

@ -0,0 +1,17 @@
#ifndef FSFW_TIMEMANAGER_CCSDSTIMESTAMPREADER_H
#define FSFW_TIMEMANAGER_CCSDSTIMESTAMPREADER_H
#include <cstdlib>
#include "TimeReaderIF.h"
class CcsdsTimestampReader : public TimeReaderIF {
public:
timeval& getTime() override;
private:
timeval time{};
size_t timestampLen = 0;
};
#endif // FSFW_TIMEMANAGER_CCSDSTIMESTAMPREADER_H

View File

@ -0,0 +1,49 @@
#include "fsfw/timemanager/CdsShortTimeStamper.h"
#include <cstring>
#include "fsfw/timemanager/Clock.h"
CdsShortTimeStamper::CdsShortTimeStamper(object_id_t objectId) : SystemObject(objectId) {}
ReturnValue_t CdsShortTimeStamper::addTimeStamp(uint8_t *buffer, const uint8_t maxSize) {
size_t serLen = 0;
return serialize(&buffer, &serLen, maxSize, SerializeIF::Endianness::NETWORK);
}
ReturnValue_t CdsShortTimeStamper::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const {
if (*size + getSerializedSize() > maxSize) {
return SerializeIF::BUFFER_TOO_SHORT;
}
timeval now{};
Clock::getClock_timeval(&now);
CCSDSTime::CDS_short cds{};
ReturnValue_t result = CCSDSTime::convertToCcsds(&cds, &now);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
std::memcpy(*buffer, &cds, sizeof(cds));
*buffer += getSerializedSize();
*size += getSerializedSize();
return result;
}
size_t CdsShortTimeStamper::getSerializedSize() const { return getTimestampSize(); }
ReturnValue_t CdsShortTimeStamper::deSerialize(const uint8_t **buffer, size_t *size,
SerializeIF::Endianness streamEndianness) {
return HasReturnvaluesIF::RETURN_FAILED;
}
ReturnValue_t CdsShortTimeStamper::readTimeStamp(const uint8_t *buffer, size_t maxSize) {
if (maxSize < getTimestampSize()) {
return SerializeIF::STREAM_TOO_SHORT;
}
size_t foundLen = 0;
return CCSDSTime::convertFromCcsds(&readTime, buffer, &foundLen, maxSize);
}
timeval &CdsShortTimeStamper::getTime() { return readTime; }
size_t CdsShortTimeStamper::getTimestampSize() const { return TIMESTAMP_LEN; }

View File

@ -1,9 +1,10 @@
#ifndef FSFW_TIMEMANAGER_TIMESTAMPER_H_ #ifndef FSFW_TIMEMANAGER_TIMESTAMPER_H_
#define FSFW_TIMEMANAGER_TIMESTAMPER_H_ #define FSFW_TIMEMANAGER_TIMESTAMPER_H_
#include "../objectmanager/SystemObject.h"
#include "CCSDSTime.h" #include "CCSDSTime.h"
#include "TimeReaderIF.h"
#include "TimeStamperIF.h" #include "TimeStamperIF.h"
#include "fsfw/objectmanager/SystemObject.h"
/** /**
* @brief Time stamper which can be used to add any timestamp to a * @brief Time stamper which can be used to add any timestamp to a
@ -14,14 +15,15 @@
* overriding the #addTimeStamp function. * overriding the #addTimeStamp function.
* @ingroup utility * @ingroup utility
*/ */
class TimeStamper : public TimeStamperIF, public SystemObject { class CdsShortTimeStamper : public TimeStamperIF, public TimeReaderIF, public SystemObject {
public: public:
static constexpr size_t TIMESTAMP_LEN = 7;
/** /**
* @brief Default constructor which also registers the time stamper as a * @brief Default constructor which also registers the time stamper as a
* system object so it can be found with the #objectManager. * system object so it can be found with the #objectManager.
* @param objectId * @param objectId
*/ */
TimeStamper(object_id_t objectId); explicit CdsShortTimeStamper(object_id_t objectId);
/** /**
* Adds a CCSDS CDC short 8 byte timestamp to the given buffer. * Adds a CCSDS CDC short 8 byte timestamp to the given buffer.
@ -30,7 +32,18 @@ class TimeStamper : public TimeStamperIF, public SystemObject {
* @param maxSize * @param maxSize
* @return * @return
*/ */
virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize); ReturnValue_t addTimeStamp(uint8_t *buffer, uint8_t maxSize) override;
ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
Endianness streamEndianness) const override;
[[nodiscard]] size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
Endianness streamEndianness) override;
ReturnValue_t readTimeStamp(const uint8_t *buffer, size_t maxSize) override;
timeval &getTime() override;
[[nodiscard]] size_t getTimestampSize() const override;
private:
timeval readTime{};
}; };
#endif /* FSFW_TIMEMANAGER_TIMESTAMPER_H_ */ #endif /* FSFW_TIMEMANAGER_TIMESTAMPER_H_ */

View File

@ -11,7 +11,7 @@
#ifdef WIN32 #ifdef WIN32
#include <winsock2.h> #include <winsock2.h>
#else #else
#include <sys/time.h> #include <ctime>
#endif #endif
class Clock { class Clock {
@ -33,7 +33,7 @@ class Clock {
* *
* @deprecated, we should not worry about ticks, but only time * @deprecated, we should not worry about ticks, but only time
*/ */
static uint32_t getTicksPerSecond(void); static uint32_t getTicksPerSecond();
/** /**
* This system call sets the system time. * This system call sets the system time.
* To set the time, it uses a TimeOfDay_t struct. * To set the time, it uses a TimeOfDay_t struct.
@ -148,7 +148,7 @@ class Clock {
* @return * @return
* - @c RETURN_OK on success. * - @c RETURN_OK on success.
*/ */
static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_); static ReturnValue_t setLeapSeconds(uint16_t leapSeconds_);
/** /**
* Get the Leap Seconds since 1972 * Get the Leap Seconds since 1972

View File

@ -1,7 +1,7 @@
#ifndef FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_ #ifndef FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_
#define FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_ #define FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_
#include "../ipc/MessageQueueSenderIF.h" #include "fsfw/ipc/MessageQueueSenderIF.h"
/** /**
* This is a Interface for classes that receive timing information * This is a Interface for classes that receive timing information
@ -13,11 +13,11 @@ class ReceivesTimeInfoIF {
* Returns the id of the queue which receives the timing information. * Returns the id of the queue which receives the timing information.
* @return Queue id of the timing queue. * @return Queue id of the timing queue.
*/ */
virtual MessageQueueId_t getTimeReceptionQueue() const = 0; [[nodiscard]] virtual MessageQueueId_t getTimeReceptionQueue() const = 0;
/** /**
* Empty virtual destructor. * Empty virtual destructor.
*/ */
virtual ~ReceivesTimeInfoIF() {} virtual ~ReceivesTimeInfoIF() = default;
}; };
#endif /* FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_ */ #endif /* FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_ */

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