2021-07-13 20:22:54 +02:00
|
|
|
#include "fsfw/tmtcservices/PusServiceBase.h"
|
2020-12-14 21:30:39 +01:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
#include "fsfw/ipc/QueueFactory.h"
|
2021-07-13 20:22:54 +02:00
|
|
|
#include "fsfw/objectmanager/ObjectManager.h"
|
|
|
|
#include "fsfw/serviceinterface/ServiceInterface.h"
|
|
|
|
#include "fsfw/tcdistribution/PUSDistributorIF.h"
|
2022-02-02 10:29:30 +01:00
|
|
|
#include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
|
|
|
|
#include "fsfw/tmtcservices/PusVerificationReport.h"
|
|
|
|
#include "fsfw/tmtcservices/TmTcMessage.h"
|
2022-07-21 13:48:58 +02:00
|
|
|
#include "fsfw/tmtcservices/tcHelpers.h"
|
2016-06-15 23:48:41 +02:00
|
|
|
|
2022-07-26 18:46:28 +02:00
|
|
|
object_id_t PusServiceBase::PACKET_DESTINATION = 0;
|
|
|
|
object_id_t PusServiceBase::PUS_DISTRIBUTOR = 0;
|
2018-07-12 16:29:32 +02:00
|
|
|
|
2022-07-26 16:49:46 +02:00
|
|
|
PusServiceBase::PusServiceBase(PsbParams params)
|
|
|
|
: SystemObject(params.objectId), psbParams(params) {}
|
2016-06-15 23:48:41 +02:00
|
|
|
|
2022-07-26 16:49:46 +02:00
|
|
|
PusServiceBase::~PusServiceBase() {
|
|
|
|
if (ownedQueue) {
|
|
|
|
QueueFactory::instance()->deleteMessageQueue(psbParams.reqQueue);
|
|
|
|
}
|
|
|
|
}
|
2016-06-15 23:48:41 +02:00
|
|
|
|
2018-07-12 16:29:32 +02:00
|
|
|
ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
|
2022-02-02 10:29:30 +01:00
|
|
|
handleRequestQueue();
|
2022-07-26 14:14:00 +02:00
|
|
|
ReturnValue_t result = performService();
|
2022-02-02 10:29:30 +01:00
|
|
|
if (result != RETURN_OK) {
|
2021-01-03 14:16:52 +01:00
|
|
|
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
2022-07-27 10:49:49 +02:00
|
|
|
sif::error << "PusService " << psbParams.serviceId << ": performService returned with "
|
|
|
|
<< static_cast<uint16_t>(result) << std::endl;
|
2021-01-03 13:58:18 +01:00
|
|
|
#endif
|
2022-02-02 10:29:30 +01:00
|
|
|
return RETURN_FAILED;
|
|
|
|
}
|
|
|
|
return RETURN_OK;
|
2020-06-10 20:49:30 +02:00
|
|
|
}
|
|
|
|
|
2022-07-19 18:13:25 +02:00
|
|
|
void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle_) { this->taskHandle = taskHandle_; }
|
2020-06-29 16:57:00 +02:00
|
|
|
|
2020-06-10 20:49:30 +02:00
|
|
|
void PusServiceBase::handleRequestQueue() {
|
2022-02-02 10:29:30 +01:00
|
|
|
TmTcMessage message;
|
2022-07-20 22:21:15 +02:00
|
|
|
ReturnValue_t result;
|
2022-02-02 10:29:30 +01:00
|
|
|
for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
|
2022-07-26 16:49:46 +02:00
|
|
|
ReturnValue_t status = psbParams.reqQueue->receiveMessage(&message);
|
2022-07-21 11:34:11 +02:00
|
|
|
if (status == MessageQueueIF::EMPTY) {
|
2022-02-02 10:29:30 +01:00
|
|
|
break;
|
2022-07-21 11:34:11 +02:00
|
|
|
} else if (status != HasReturnvaluesIF::RETURN_OK) {
|
2021-01-03 14:16:52 +01:00
|
|
|
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
2022-07-27 10:49:49 +02:00
|
|
|
sif::error << "PusServiceBase::performOperation: Service " << psbParams.serviceId
|
2022-02-02 10:29:30 +01:00
|
|
|
<< ": Error receiving packet. Code: " << std::hex << status << std::dec
|
|
|
|
<< std::endl;
|
2022-07-21 11:34:11 +02:00
|
|
|
#else
|
|
|
|
sif::printError(
|
|
|
|
"PusServiceBase::performOperation: Service %d. Error receiving packet. Code: %04x\n",
|
2022-07-26 16:49:46 +02:00
|
|
|
psbParams.serviceId, status);
|
2021-01-03 13:58:18 +01:00
|
|
|
#endif
|
2022-07-21 11:34:11 +02:00
|
|
|
break;
|
|
|
|
}
|
2022-07-26 17:41:10 +02:00
|
|
|
result = tc::prepareTcReader(*psbParams.tcPool, message.getStorageId(), currentPacket);
|
2022-07-21 11:34:11 +02:00
|
|
|
if (result != HasReturnvaluesIF::RETURN_OK) {
|
2022-07-26 17:41:10 +02:00
|
|
|
// We were not even able to retrieve the TC, so we can not retrieve any TC properties either
|
|
|
|
// without segfaulting
|
|
|
|
auto verifParams = VerifFailureParams(tcverif::START_FAILURE, 0, 0, result);
|
2022-07-26 16:49:46 +02:00
|
|
|
verifParams.errorParam1 = errorParameter1;
|
|
|
|
verifParams.errorParam2 = errorParameter2;
|
|
|
|
psbParams.verifReporter->sendFailureReport(verifParams);
|
2022-07-21 11:34:11 +02:00
|
|
|
continue;
|
|
|
|
}
|
2022-07-26 13:59:09 +02:00
|
|
|
result = handleRequest(currentPacket.getSubService());
|
2022-07-21 11:34:11 +02:00
|
|
|
if (result == RETURN_OK) {
|
2022-07-26 16:49:46 +02:00
|
|
|
psbParams.verifReporter->sendSuccessReport(
|
2022-07-26 13:59:09 +02:00
|
|
|
VerifSuccessParams(tcverif::COMPLETION_SUCCESS, currentPacket));
|
2022-07-21 11:34:11 +02:00
|
|
|
} else {
|
2022-07-26 16:49:46 +02:00
|
|
|
auto failParams = VerifFailureParams(tcverif::COMPLETION_FAILURE, currentPacket, result);
|
|
|
|
failParams.errorParam1 = errorParameter1;
|
|
|
|
failParams.errorParam2 = errorParameter2;
|
|
|
|
psbParams.verifReporter->sendFailureReport(failParams);
|
2021-12-03 15:37:49 +01:00
|
|
|
}
|
2022-07-26 17:41:10 +02:00
|
|
|
psbParams.tcPool->deleteData(message.getStorageId());
|
2022-07-21 11:34:11 +02:00
|
|
|
errorParameter1 = 0;
|
|
|
|
errorParameter2 = 0;
|
2022-02-02 10:29:30 +01:00
|
|
|
}
|
2016-06-15 23:48:41 +02:00
|
|
|
}
|
|
|
|
|
2022-07-26 16:49:46 +02:00
|
|
|
uint16_t PusServiceBase::getIdentifier() { return psbParams.serviceId; }
|
2016-06-15 23:48:41 +02:00
|
|
|
|
2022-07-26 18:46:28 +02:00
|
|
|
MessageQueueId_t PusServiceBase::getRequestQueue() {
|
|
|
|
if (psbParams.reqQueue == nullptr) {
|
|
|
|
return MessageQueueIF::NO_QUEUE;
|
|
|
|
}
|
|
|
|
return psbParams.reqQueue->getId();
|
|
|
|
}
|
2016-06-15 23:48:41 +02:00
|
|
|
|
|
|
|
ReturnValue_t PusServiceBase::initialize() {
|
2022-02-02 10:29:30 +01:00
|
|
|
ReturnValue_t result = SystemObject::initialize();
|
|
|
|
if (result != RETURN_OK) {
|
|
|
|
return result;
|
|
|
|
}
|
2022-07-26 16:49:46 +02:00
|
|
|
if (psbParams.reqQueue == nullptr) {
|
|
|
|
ownedQueue = true;
|
|
|
|
psbParams.reqQueue = QueueFactory::instance()->createMessageQueue(PSB_DEFAULT_QUEUE_DEPTH);
|
|
|
|
} else {
|
|
|
|
ownedQueue = false;
|
|
|
|
}
|
2022-07-26 18:46:28 +02:00
|
|
|
|
2022-07-26 16:49:46 +02:00
|
|
|
if (psbParams.tmReceiver == nullptr) {
|
2022-07-26 18:46:28 +02:00
|
|
|
psbParams.tmReceiver = ObjectManager::instance()->get<AcceptsTelemetryIF>(PACKET_DESTINATION);
|
2022-07-26 16:49:46 +02:00
|
|
|
if (psbParams.tmReceiver != nullptr) {
|
|
|
|
psbParams.reqQueue->setDefaultDestination(psbParams.tmReceiver->getReportReceptionQueue());
|
|
|
|
}
|
2022-02-02 10:29:30 +01:00
|
|
|
}
|
2022-07-26 16:49:46 +02:00
|
|
|
|
2022-07-26 18:46:28 +02:00
|
|
|
if (psbParams.pusDistributor == nullptr) {
|
|
|
|
psbParams.pusDistributor = ObjectManager::instance()->get<PUSDistributorIF>(PUS_DISTRIBUTOR);
|
2022-07-26 17:41:10 +02:00
|
|
|
if (psbParams.pusDistributor != nullptr) {
|
|
|
|
registerService(*psbParams.pusDistributor);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (psbParams.tcPool == nullptr) {
|
|
|
|
psbParams.tcPool = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
|
|
|
|
if (psbParams.tcPool == nullptr) {
|
2022-07-20 11:43:16 +02:00
|
|
|
return ObjectManagerIF::CHILD_INIT_FAILED;
|
|
|
|
}
|
|
|
|
}
|
2022-07-26 16:49:46 +02:00
|
|
|
|
|
|
|
if (psbParams.verifReporter == nullptr) {
|
|
|
|
psbParams.verifReporter =
|
2022-07-26 13:59:09 +02:00
|
|
|
ObjectManager::instance()->get<VerificationReporterIF>(objects::TC_VERIFICATOR);
|
2022-07-26 16:49:46 +02:00
|
|
|
if (psbParams.verifReporter == nullptr) {
|
2022-07-26 13:59:09 +02:00
|
|
|
return ObjectManagerIF::CHILD_INIT_FAILED;
|
|
|
|
}
|
|
|
|
}
|
2022-02-02 10:29:30 +01:00
|
|
|
return HasReturnvaluesIF::RETURN_OK;
|
2016-06-15 23:48:41 +02:00
|
|
|
}
|
2020-06-29 16:57:00 +02:00
|
|
|
|
2022-07-26 18:46:28 +02:00
|
|
|
void PusServiceBase::setTcPool(StorageManagerIF& tcPool) { psbParams.tcPool = &tcPool; }
|
2022-07-20 22:21:15 +02:00
|
|
|
|
2022-07-26 18:46:28 +02:00
|
|
|
void PusServiceBase::setErrorReporter(InternalErrorReporterIF& errReporter_) {
|
|
|
|
psbParams.errReporter = &errReporter_;
|
2022-07-20 22:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void PusServiceBase::initializeTmHelpers(TmSendHelper& tmSendHelper, TmStoreHelper& tmStoreHelper) {
|
|
|
|
initializeTmSendHelper(tmSendHelper);
|
|
|
|
initializeTmStoreHelper(tmStoreHelper);
|
|
|
|
}
|
|
|
|
|
|
|
|
void PusServiceBase::initializeTmSendHelper(TmSendHelper& tmSendHelper) {
|
2022-07-26 16:49:46 +02:00
|
|
|
if (psbParams.reqQueue != nullptr) {
|
|
|
|
tmSendHelper.setMsgQueue(*psbParams.reqQueue);
|
|
|
|
tmSendHelper.setDefaultDestination(psbParams.reqQueue->getDefaultDestination());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (psbParams.errReporter == nullptr) {
|
|
|
|
psbParams.errReporter =
|
2022-07-20 22:21:15 +02:00
|
|
|
ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
|
2022-07-26 16:49:46 +02:00
|
|
|
if (psbParams.errReporter != nullptr) {
|
2022-07-26 18:46:28 +02:00
|
|
|
tmSendHelper.setInternalErrorReporter(*psbParams.errReporter);
|
2022-07-20 22:21:15 +02:00
|
|
|
}
|
2022-07-26 18:46:28 +02:00
|
|
|
} else {
|
|
|
|
tmSendHelper.setInternalErrorReporter(*psbParams.errReporter);
|
2022-07-20 22:21:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void PusServiceBase::initializeTmStoreHelper(TmStoreHelper& tmStoreHelper) const {
|
2022-07-26 16:49:46 +02:00
|
|
|
tmStoreHelper.setApid(psbParams.apid);
|
2022-07-20 22:21:15 +02:00
|
|
|
}
|
2022-07-26 13:59:09 +02:00
|
|
|
|
2022-07-26 18:46:28 +02:00
|
|
|
void PusServiceBase::setVerificationReporter(VerificationReporterIF& reporter) {
|
|
|
|
psbParams.verifReporter = &reporter;
|
2022-07-26 16:49:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ReturnValue_t PusServiceBase::registerService(PUSDistributorIF& distributor) {
|
|
|
|
return distributor.registerService(this);
|
|
|
|
}
|
|
|
|
|
2022-07-26 18:46:28 +02:00
|
|
|
void PusServiceBase::setTmReceiver(AcceptsTelemetryIF& tmReceiver_) {
|
|
|
|
psbParams.tmReceiver = &tmReceiver_;
|
2022-07-26 13:59:09 +02:00
|
|
|
}
|
2022-07-26 16:49:46 +02:00
|
|
|
|
2022-07-26 18:46:28 +02:00
|
|
|
void PusServiceBase::setRequestQueue(MessageQueueIF& reqQueue) { psbParams.reqQueue = &reqQueue; }
|