eive-obsw/mission/system/objects/ComSubsystem.cpp

199 lines
6.4 KiB
C++
Raw Normal View History

#include "ComSubsystem.h"
2022-04-14 09:54:07 +02:00
#include <fsfw/events/EventManagerIF.h>
#include <fsfw/ipc/MutexGuard.h>
#include <fsfw/ipc/QueueFactory.h>
#include <fsfw/serviceinterface/ServiceInterface.h>
#include <linux/ipcore/PdecHandler.h>
2023-02-22 13:02:40 +01:00
#include <mission/comDefs.h>
#include <mission/config/comCfg.h>
2023-02-22 13:02:40 +01:00
#include <utility>
2022-09-29 19:40:00 +02:00
ComSubsystem::ComSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences,
uint32_t maxNumberOfTables, uint32_t transmitterTimeout)
: Subsystem(setObjectId, maxNumberOfSequences, maxNumberOfTables), paramHelper(this) {
com::setCurrentDatarate(com::Datarate::LOW_RATE_MODULATION_BPSK);
auto mqArgs = MqArgs(setObjectId, static_cast<void *>(this));
eventQueue =
QueueFactory::instance()->createMessageQueue(10, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
transmitterCountdown.setTimeout(transmitterTimeout);
}
void ComSubsystem::performChildOperation() {
readEventQueue();
2023-02-22 13:02:40 +01:00
// Execute default rate sequence after transition has been completed
if (rememberBitLock and not isInTransition) {
startRxAndTxLowRateSeq();
rememberBitLock = false;
}
2023-02-22 09:53:09 +01:00
if (countdownActive) {
2023-02-22 13:02:40 +01:00
checkTransmitterCountdown();
2023-02-16 13:40:15 +01:00
}
2023-02-22 09:53:09 +01:00
Subsystem::performChildOperation();
}
MessageQueueId_t ComSubsystem::getCommandQueue() const { return Subsystem::getCommandQueue(); }
ReturnValue_t ComSubsystem::getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
ParameterWrapper *parameterWrapper,
const ParameterWrapper *newValues, uint16_t startAtIndex) {
if ((domainId == 0) and (uniqueIdentifier == static_cast<uint8_t>(com::ParameterId::DATARATE))) {
uint8_t newVal = 0;
ReturnValue_t result = newValues->getElement(&newVal);
if (result != returnvalue::OK) {
return result;
}
if (newVal >= static_cast<uint8_t>(com::Datarate::NUM_DATARATES)) {
return HasParametersIF::INVALID_VALUE;
}
parameterWrapper->set(datarateCfg);
com::setCurrentDatarate(static_cast<com::Datarate>(newVal));
return returnvalue::OK;
2023-02-22 13:02:40 +01:00
} else if ((domainId == 0) and
(uniqueIdentifier == static_cast<uint8_t>(com::ParameterId::TRANSMITTER_TIMEOUT))) {
uint32_t newVal = 0;
ReturnValue_t result = newValues->getElement(&newVal);
if (result != returnvalue::OK) {
return result;
}
parameterWrapper->set(transmitterTimeout);
transmitterTimeout = newVal;
transmitterCountdown.setTimeout(transmitterTimeout);
return returnvalue::OK;
}
return returnvalue::OK;
}
2023-01-28 14:49:28 +01:00
ReturnValue_t ComSubsystem::handleCommandMessage(CommandMessage *message) {
ReturnValue_t result = paramHelper.handleParameterMessage(message);
if (result == returnvalue::OK) {
return result;
}
return Subsystem::handleCommandMessage(message);
}
ReturnValue_t ComSubsystem::initialize() {
ReturnValue_t result = paramHelper.initialize();
if (result != returnvalue::OK) {
return result;
}
2023-02-22 13:02:40 +01:00
EventManagerIF *manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
if (manager == nullptr) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
2023-02-22 13:02:40 +01:00
sif::error << "ComSubsystem::initialize: Invalid event manager" << std::endl;
#endif
2023-02-22 13:02:40 +01:00
return ObjectManagerIF::CHILD_INIT_FAILED;
}
result = manager->registerListener(eventQueue->getId());
if (result != returnvalue::OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
2023-02-22 13:02:40 +01:00
sif::warning << "ComSubsystem::initialize: Failed to register Com Subsystem as event "
"listener"
<< std::endl;
#endif
2023-02-22 13:02:40 +01:00
return ObjectManagerIF::CHILD_INIT_FAILED;
}
result = manager->subscribeToEventRange(eventQueue->getId(),
event::getEventId(PdecHandler::CARRIER_LOCK),
event::getEventId(PdecHandler::BIT_LOCK_PDEC));
if (result != returnvalue::OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
2023-02-22 13:02:40 +01:00
sif::error << "ComSubsystem::initialize: Failed to subscribe to events from PDEC "
"handler"
<< std::endl;
#endif
2023-02-22 13:02:40 +01:00
return result;
}
2023-01-28 14:49:28 +01:00
return Subsystem::initialize();
}
void ComSubsystem::startTransition(Mode_t mode, Submode_t submode) {
2023-02-16 13:40:15 +01:00
// Depending on the submode the transmitter timeout is enabled or
// disabled here
2023-02-22 13:02:40 +01:00
if (mode == com::Submode::RX_ONLY) {
transmitterCountdown.timeOut();
2023-02-22 09:53:09 +01:00
countdownActive = false;
2023-02-22 13:02:40 +01:00
} else if (isTxMode(mode)) {
2023-02-22 19:45:41 +01:00
// Only start transmitter countdown if transmitter is not already on
if (not isTxMode(this->mode)) {
transmitterCountdown.resetTimer();
countdownActive = true;
}
}
Subsystem::startTransition(mode, submode);
}
void ComSubsystem::readEventQueue() {
EventMessage event;
for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == returnvalue::OK;
result = eventQueue->receiveMessage(&event)) {
switch (event.getMessageId()) {
case EventMessage::EVENT_MESSAGE:
handleEventMessage(&event);
break;
default:
sif::debug << "CcsdsHandler::checkEvents: Did not subscribe to this event message"
<< std::endl;
break;
}
}
}
void ComSubsystem::handleEventMessage(EventMessage *eventMessage) {
Event event = eventMessage->getEvent();
switch (event) {
case PdecHandler::BIT_LOCK_PDEC: {
handleBitLockEvent();
break;
}
case PdecHandler::CARRIER_LOCK: {
handleCarrierLockEvent();
break;
}
default:
sif::debug << "ComSubsystem::handleEvent: Did not subscribe to this event" << std::endl;
break;
}
}
2023-02-22 13:02:40 +01:00
void ComSubsystem::handleBitLockEvent() {
if (isTxMode(mode)) {
// Tx already on
return;
}
if (isInTransition) {
rememberBitLock = true;
return;
}
startRxAndTxLowRateSeq();
}
void ComSubsystem::handleCarrierLockEvent() {
if (!enableTxWhenCarrierLock) {
return;
}
2023-02-22 13:02:40 +01:00
startRxAndTxLowRateSeq();
}
2023-02-22 13:02:40 +01:00
void ComSubsystem::startRxAndTxLowRateSeq() {
// Turns transmitter on
2023-02-22 13:02:40 +01:00
startTransition(com::Submode::RX_AND_TX_LOW_DATARATE, SUBMODE_NONE);
}
void ComSubsystem::checkTransmitterCountdown() {
if (transmitterCountdown.hasTimedOut()) {
2023-02-22 13:02:40 +01:00
startTransition(com::Submode::RX_ONLY, SUBMODE_NONE);
2023-02-22 09:53:09 +01:00
countdownActive = false;
}
}
2023-02-22 13:02:40 +01:00
bool ComSubsystem::isTxMode(Mode_t mode) {
2023-02-22 19:45:41 +01:00
if ((mode == com::Submode::RX_AND_TX_DEFAULT_DATARATE) ||
(mode == com::Submode::RX_AND_TX_LOW_DATARATE) ||
(mode == com::Submode::RX_AND_TX_HIGH_DATARATE)) {
return true;
}
return false;
2023-02-22 13:02:40 +01:00
}