eive/eive-obsw
13
4
Fork 0
Code Issues 4 Pull Requests 1 Releases 121 Wiki Activity

ccsds handler wip

Browse Source
This commit is contained in:
Jakob Meier
2021-09-22 16:54:55 +02:00
parent e2c26efe4a
commit d54e2276d6
12 changed files with 327 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

167
mission/tmtc/CCSDSHandler.cpp
View File

@ -1,13 +1,3 @@
/*******************************
* FLP Flight Software Framework (FSFW)
* (c) 2016 IRS, Uni Stuttgart
*******************************/
/*
* CCSDSHandler.cpp
*
* Created on: Feb 9, 2012
* Author: baetz
*/
#include <framework/devicehandlers/DeviceHandlerIF.h>
#include <framework/objectmanager/ObjectManagerIF.h>
#include <framework/rmap/RMAPChannelIF.h>
@ -121,9 +111,30 @@ ReturnValue_t CCSDSHandler::packetProcessingCheck(void) {
ReturnValue_t CCSDSHandler::performOperation(void) {
readCommandQueue();
handleTelemetry();
handleTelecommands();
return RETURN_OK;
}
void CCSDSHandler::addVirtualChannel(VcId_t virtualChannelId, VirtualChannel* virtualChannel) {
auto status = virtualChannelMap.emplace(virtualChannelId, virtualChannel);
if (status.second == false) {
sif::warning << "CCSDSHandler::addVcInterface: Failed to add virtual channel with virtual "
<< "channel id " << static_cast<unsigned int>(virtualChannelId) << std::endl;
}
}
void CCSDSHandler::handleTelemetry() {
VirtualChannelMapIter iter;
for (iter = virtualChannelMap.begin(); iter != VirtualChannelMap.end(); iter++) {
iter->second.virtualChannel->performOperation();
}
}
void CCSDSHandler::handleTelecommands() {
}
void CCSDSHandler::searchFrame() {
frameLength = this->boardHandler.findFrame();
while (frameLength != 0) {
@ -198,17 +209,18 @@ ReturnValue_t CCSDSHandler::initialize() {
void CCSDSHandler::readCommandQueue(void) {
CommandMessage commandMessage;
ReturnValue_t result = RETURN_FAILED;
while (commandQueue.receiveMessage(&commandMessage) == RETURN_OK) {
result = parameterHelper.handleParameterMessage(&commandMessage);
if (result == RETURN_OK) {
return;
}
CommandMessage reply;
reply.setReplyRejected(CommandMessage::UNKNOW_COMMAND,
commandMessage.getCommand());
commandQueue.reply(&reply);
}
result = commandQueue.receiveMessage(&commandMessage);
if (result == RETURN_OK) {
result = parameterHelper.handleParameterMessage(&commandMessage);
if (result == RETURN_OK) {
return;
}
CommandMessage reply;
reply.setReplyRejected(CommandMessage::UNKNOW_COMMAND,
commandMessage.getCommand());
commandQueue.reply(&reply);
}
}
MessageQueueId_t CCSDSHandler::getCommandQueue() const {
@ -486,120 +498,15 @@ Submode_t CCSDSHandler::getSubmode() const {
}
MessageQueueId_t CCSDSHandler::getReportReceptionQueue(uint8_t virtualChannel) {
if (virtualChannel < Ptme::NUM_OF_VIRTUAL_CHANNELS) {
if (virtualChannel < config::NUMBER_OF_VIRTUAL_CHANNELS) {
return virtualChannels[virtualChannel]->getReportReceptionQueue();
} else {
sif::debug << "CCSDSHandler::getReportReceptionQueue: Invalid virtual channel requested";
}
}
void CCSDSHandler::executeAllWriteCommands() {
ReturnValue_t returnValue = boardHandler.sendWriteCommands();
if (returnValue != RETURN_OK) {
triggerEvent(DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED,
returnValue, 0);
}
if (submode == SUBMODE_ACTIVE) {
returnValue = this->packetProcessing();
if (returnValue != RETURN_OK) {
triggerEvent(DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED,
returnValue, 1);
}
}
}
void CCSDSHandler::handleAllWriteReplies() {
ReturnValue_t returnValue = boardHandler.getWriteReplys();
if (returnValue != RETURN_OK) {
triggerEvent(DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED,
returnValue, 0);
}
if (pendingWrite) {
memoryHelper.completeLoad(returnValue);
pendingWrite = false;
}
if (submode == SUBMODE_ACTIVE) {
returnValue = packetProcessingCheck();
} else {
this->flushTmChannels();
}
}
void CCSDSHandler::executeAllReadCommands() {
ReturnValue_t returnValue = boardHandler.sendReadCommands();
if (returnValue != RETURN_OK) {
triggerEvent(DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED,
returnValue, 0);
}
}
void CCSDSHandler::handleAllReadReplies() {
if ((mode == MODE_ON) && (state == STATE_IDLE)) {
ReturnValue_t returnValue = boardHandler.getReadReplys();
if (returnValue == RETURN_OK) {
searchFrame();
} else {
triggerEvent(DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED,
returnValue, 0);
//do nothing.
}
if (pendingRead) {
uint8_t* tempBuffer;
returnValue = boardHandler.getRegisterReadReply(&tempBuffer);
memoryHelper.completeDump(returnValue, tempBuffer,
BoardHandler::REGISTER_LENGTH);
pendingRead = false;
}
}
}
ReturnValue_t CCSDSHandler::getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
uint16_t startAtIndex) {
ReturnValue_t result = fdir.getParameter(domainId, parameterId,
parameterWrapper, newValues, startAtIndex);
if (result != INVALID_DOMAIN_ID) {
return result;
}
if (domainId != DOMAIN_ID_BASE) {
return INVALID_DOMAIN_ID;
}
switch (parameterId) {
case 0:
parameterWrapper->set(boardHandler.tmPhysicalLayerRegisterValue);
break;
case 1:
parameterWrapper->set(boardHandler.tmCodingSublayerRegisterValue);
break;
default:
return INVALID_MATRIX_ID;
}
return RETURN_OK;
}
ReturnValue_t CCSDSHandler::setHealth(HealthState health) {
healthHelper.setHealth(health);
return RETURN_OK;
}
HasHealthIF::HealthState CCSDSHandler::getHealth() {
return healthHelper.getHealth();
}
CCSDSHandler::DataRateSet::DataRateSet() :
ControllerSet(), dataRate(datapool::VC_DATA_RATE_RAW, this,
PoolVariableIF::VAR_WRITE), dataRates(
datapool::DATA_RATE_ASSIGN, this, PoolVariableIF::VAR_READ) {
}
CCSDSHandler::DataRateSet::~DataRateSet() {
}
void CCSDSHandler::DataRateSet::setToDefault() {
dataRate.value = {0.0, 0.0, 0.0, 0.0};
}
void CCSDSHandler::triggerEvent(Event event, uint32_t parameter1,
uint32_t parameter2) {
fdir.triggerEvent(event, parameter1, parameter2);
ReturnValue_t CCSDSHandler::getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
uint16_t startAtIndex) {
return RETURN_OK;
}