KSat/fsfw
15
4
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests 1 Releases Wiki Activity

Merge pull request 'PUS: PUS Services' (#139) from KSat/fsfw:mueller_PusServices into master

Browse Source
This commit is contained in:
Steffen Gaisser 2020-08-12 10:07:36 +02:00
commit e535bc1427
17 changed files with 1548 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
events/fwSubsystemIdRanges.h
View File

@ -18,6 +18,8 @@ enum {
SYSTEM_MANAGER = 74,
SYSTEM_MANAGER_1 = 75,
SYSTEM_1 = 79,
PUS_SERVICE_1 = 80,
FW_SUBSYSTEM_ID_RANGE
};
}

1
framework.mk
View File

@ -55,3 +55,4 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp)
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)

119
pus/CService200ModeCommanding.cpp Normal file
View File

@ -0,0 +1,119 @@
#include <framework/pus/CService200ModeCommanding.h>
#include <framework/pus/servicepackets/Service200Packets.h>
#include <framework/modes/HasModesIF.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
#include <framework/serialize/SerialLinkedListAdapter.h>
#include <framework/modes/ModeMessage.h>
CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
uint16_t apid, uint8_t serviceId):
CommandingServiceBase(objectId, apid, serviceId,
NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {}
CService200ModeCommanding::~CService200ModeCommanding() {}
ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
switch(subservice) {
case(Subservice::COMMAND_MODE_COMMAND):
case(Subservice::COMMAND_MODE_READ):
case(Subservice::COMMAND_MODE_ANNCOUNCE):
return RETURN_OK;
default:
return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
}
}
ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject(
uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
MessageQueueId_t *id, object_id_t *objectId) {
if(tcDataLen < sizeof(object_id_t)) {
return CommandingServiceBase::INVALID_TC;
}
SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
SerializeIF::Endianness::BIG);
return checkInterfaceAndAcquireMessageQueue(id,objectId);
}
ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
HasModesIF * destination = objectManager->get<HasModesIF>(*objectId);
if(destination == nullptr) {
return CommandingServiceBase::INVALID_OBJECT;
}
*messageQueueToSet = destination->getCommandQueue();
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t CService200ModeCommanding::prepareCommand(
CommandMessage* message,uint8_t subservice, const uint8_t *tcData,
size_t tcDataLen, uint32_t *state, object_id_t objectId) {
ModePacket modeCommandPacket;
ReturnValue_t result = modeCommandPacket.deSerialize(&tcData,
&tcDataLen, SerializeIF::Endianness::BIG);
if (result != RETURN_OK) {
return result;
}
ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
modeCommandPacket.getSubmode());
return result;
}
ReturnValue_t CService200ModeCommanding::handleReply(
const CommandMessage* reply, Command_t previousCommand,
uint32_t *state, CommandMessage* optionalNextCommand,
object_id_t objectId, bool *isStep) {
Command_t replyId = reply->getCommand();
ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
switch(replyId) {
case(ModeMessage::REPLY_MODE_REPLY): {
result = prepareModeReply(reply, objectId);
break;
}
case(ModeMessage::REPLY_WRONG_MODE_REPLY): {
result = prepareWrongModeReply(reply, objectId);
break;
}
case(ModeMessage::REPLY_CANT_REACH_MODE): {
result = prepareCantReachModeReply(reply, objectId);
break;
}
case(ModeMessage::REPLY_MODE_INFO):
result = INVALID_REPLY;
break;
default:
result = RETURN_FAILED;
}
return result;
}
ReturnValue_t CService200ModeCommanding::prepareModeReply(
const CommandMessage *reply, object_id_t objectId) {
ModePacket modeReplyPacket(objectId,
ModeMessage::getMode(reply),
ModeMessage::getSubmode(reply));
return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket);
}
ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(
const CommandMessage *reply, object_id_t objectId) {
ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply),
ModeMessage::getSubmode(reply));
return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
}
ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
const CommandMessage *reply, object_id_t objectId) {
CantReachModePacket cantReachModePacket(objectId,
ModeMessage::getCantReachModeReason(reply));
return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
&cantReachModePacket);
}

85
pus/CService200ModeCommanding.h Normal file
View File

@ -0,0 +1,85 @@
#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
#include <framework/tmtcservices/CommandingServiceBase.h>
/**
* @brief Custom PUS service to set mode of all objects implementing HasModesIF
*
* Examples: Device Handlers, Assemblies or Subsystems.
* Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
* Dissertation Baetz p. 115, 116, 165-167.
*
* This is a gateway service. It relays device commands using the software bus.
* @ingroup pus_services
*/
class CService200ModeCommanding: public CommandingServiceBase {
public:
static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
CService200ModeCommanding(object_id_t objectId,
uint16_t apid, uint8_t serviceId);
virtual~ CService200ModeCommanding();
protected:
//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
ReturnValue_t isValidSubservice(uint8_t subservice) override;
ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
object_id_t *objectId) override;
ReturnValue_t prepareCommand(CommandMessage* message,
uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
uint32_t *state, object_id_t objectId) override;
ReturnValue_t handleReply(const CommandMessage* reply,
Command_t previousCommand, uint32_t *state,
CommandMessage* optionalNextCommand, object_id_t objectId,
bool *isStep) override;
private:
ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
const uint8_t* tcData, uint32_t tcDataLen);
ReturnValue_t checkInterfaceAndAcquireMessageQueue(
MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
ReturnValue_t prepareModeReply(const CommandMessage *reply,
object_id_t objectId);
ReturnValue_t prepareWrongModeReply(const CommandMessage *reply,
object_id_t objectId);
ReturnValue_t prepareCantReachModeReply(const CommandMessage *reply,
object_id_t objectId);
enum Subservice { //!< [EXPORT] : [COMMENT] Mode Commanding Subservices
//!< [EXPORT] : [COMMAND] Command assembly, subsystem or device mode
COMMAND_MODE_COMMAND = 1,
//!< [EXPORT] : [COMMAND] Command to set the specified Mode,
//! regardless of external control flag
COMMAND_MODE_COMMAND_FORCED = 2,
//!< [EXPORT] : [COMMAND] Read the current mode and
//! reply with a REPLY_MODE_REPLY
COMMAND_MODE_READ = 3,
//!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event.
//! This command does NOT have a reply
COMMAND_MODE_ANNCOUNCE = 4,
//!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this
//! command to every child. This command does NOT have a reply.
COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5,
//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
REPLY_MODE_REPLY = 6,
//!< [EXPORT] : [REPLY] Reply in case a mode command can't be executed.
REPLY_CANT_REACH_MODE = 7,
//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND, indicating that a
//! mode was commanded and a transition started but was aborted,
//! the parameters contain the mode that was reached
REPLY_WRONG_MODE_REPLY = 8
};
enum modeParameters {
MODE_OFF = 0,
MODE_ON = 1,
MODE_NORMAL = 2,
MODE_RAW = 3
};
};
#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */

100
pus/Service1TelecommandVerification.cpp Normal file
View File

@ -0,0 +1,100 @@
#include <framework/pus/Service1TelecommandVerification.h>
#include <framework/pus/servicepackets/Service1Packets.h>
#include <framework/ipc/QueueFactory.h>
#include <framework/tmtcservices/PusVerificationReport.h>
#include <framework/tmtcpacket/pus/TmPacketStored.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
#include <framework/tmtcservices/AcceptsTelemetryIF.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
Service1TelecommandVerification::Service1TelecommandVerification(
object_id_t objectId, uint16_t apid, uint8_t serviceId,
object_id_t targetDestination):
SystemObject(objectId), apid(apid), serviceId(serviceId),
targetDestination(targetDestination) {
tmQueue = QueueFactory::instance()->createMessageQueue();
}
Service1TelecommandVerification::~Service1TelecommandVerification() {}
MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
return tmQueue->getId();
}
ReturnValue_t Service1TelecommandVerification::performOperation(
uint8_t operationCode){
PusVerificationMessage message;
ReturnValue_t status = tmQueue->receiveMessage(&message);
while(status == HasReturnvaluesIF::RETURN_OK) {
status = sendVerificationReport(&message);
if(status != HasReturnvaluesIF::RETURN_OK) {
return status;
}
status = tmQueue->receiveMessage(&message);
}
if (status == MessageQueueIF::EMPTY) {
return HasReturnvaluesIF::RETURN_OK;
}
else {
return status;
}
}
ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
PusVerificationMessage* message) {
ReturnValue_t result;
if(message->getReportId() % 2 == 0) {
result = generateFailureReport(message);
} else {
result = generateSuccessReport(message);
}
if(result != HasReturnvaluesIF::RETURN_OK){
sif::error << "Service1TelecommandVerification::initialize: "
"Sending verification packet failed !" << std::endl;
}
return result;
}
ReturnValue_t Service1TelecommandVerification::generateFailureReport(
PusVerificationMessage *message) {
FailureReport report(
message->getReportId(), message->getTcPacketId(),
message->getTcSequenceControl(), message->getStep(),
message->getErrorCode(), message->getParameter1(),
message->getParameter2());
TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
packetSubCounter++, &report);
ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
tmQueue->getId());
return result;
}
ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
PusVerificationMessage *message) {
SuccessReport report(message->getReportId(),message->getTcPacketId(),
message->getTcSequenceControl(),message->getStep());
TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
packetSubCounter++, &report);
ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
tmQueue->getId());
return result;
}
ReturnValue_t Service1TelecommandVerification::initialize() {
// Get target object for TC verification messages
AcceptsTelemetryIF* funnel = objectManager->
get<AcceptsTelemetryIF>(targetDestination);
if(funnel == nullptr){
sif::error << "Service1TelecommandVerification::initialize: Specified"
" TM funnel invalid. Make sure it is set up and implements"
" AcceptsTelemetryIF." << std::endl;
return ObjectManagerIF::CHILD_INIT_FAILED;
}
tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
return SystemObject::initialize();
}

94
pus/Service1TelecommandVerification.h Normal file
View File

@ -0,0 +1,94 @@
#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
#include <framework/objectmanager/SystemObject.h>
#include <framework/returnvalues/HasReturnvaluesIF.h>
#include <framework/tasks/ExecutableObjectIF.h>
#include <framework/tmtcservices/AcceptsVerifyMessageIF.h>
#include <framework/tmtcservices/PusVerificationReport.h>
#include <framework/ipc/MessageQueueIF.h>
/**
* @brief Verify TC acceptance, start, progress and execution.
*
* Full Documentation: ECSS-E70-41A p.51
*
* The telecommand verification service provides the capability for
* explicit verification of each distinct stage of execution of a telecommand
* packet, from on-board acceptance through to completion of execution.
*
* Minimum capabilities of this service:
*
* - TM[1,1]: Telecommand Acceptance Report - Success.
* - TM[1,2]: Telecommand Acceptance Report - Failure.
*
* Additional capabilities of this service:
*
* - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4).
* - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3).
* - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6).
* - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5).
* - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8).
* - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7).
*
* This Service is not inherited from PUSServiceBase unlike other PUS Services
* because all services implementing PUSServiceBase use this service to
* generate verification reports.
* @ingroup pus_services
*/
class Service1TelecommandVerification: public AcceptsVerifyMessageIF,
public SystemObject,
public ExecutableObjectIF,
public HasReturnvaluesIF {
public:
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
Service1TelecommandVerification(object_id_t objectId,
uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
virtual ~Service1TelecommandVerification();
/**
*
* @return ID of Verification Queue
*/
virtual MessageQueueId_t getVerificationQueue();
/**
* Performs the service periodically as specified in init_mission().
* Triggers the handlePacket function to send TC verification messages
* @param operationCode
* @return
*/
ReturnValue_t performOperation(uint8_t operationCode = 0) override;
/**
* Initializes the destination for TC verification messages and initializes
* Service 1 as a system object
* @return
*/
ReturnValue_t initialize() override;
private:
uint16_t apid = 0;
uint8_t serviceId = 0;
object_id_t targetDestination = objects::NO_OBJECT;
ReturnValue_t sendVerificationReport(PusVerificationMessage* message);
ReturnValue_t generateFailureReport(PusVerificationMessage* message);
ReturnValue_t generateSuccessReport(PusVerificationMessage* message);
uint16_t packetSubCounter = 0;
MessageQueueIF* tmQueue = nullptr;
enum class Subservice: uint8_t {
VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM]
VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM]
VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM]
VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM]
VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM]
VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM]
};
};
#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */

167
pus/Service2DeviceAccess.cpp Normal file
View File

@ -0,0 +1,167 @@
#include <framework/pus/Service2DeviceAccess.h>
#include <framework/pus/servicepackets/Service2Packets.h>
#include <framework/devicehandlers/DeviceHandlerIF.h>
#include <framework/storagemanager/StorageManagerIF.h>
#include <framework/devicehandlers/DeviceHandlerMessage.h>
#include <framework/serialize/EndianConverter.h>
#include <framework/action/ActionMessage.h>
#include <framework/serialize/SerializeAdapter.h>
#include <framework/serialize/SerialLinkedListAdapter.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands,
uint16_t commandTimeoutSeconds):
CommandingServiceBase(objectId, apid, serviceId,
numberOfParallelCommands, commandTimeoutSeconds) {}
Service2DeviceAccess::~Service2DeviceAccess() {}
ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
switch(static_cast<Subservice>(subservice)){
case Subservice::RAW_COMMANDING:
case Subservice::TOGGLE_WIRETAPPING:
return HasReturnvaluesIF::RETURN_OK;
default:
sif::error << "Invalid Subservice" << std::endl;
return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
}
}
ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
MessageQueueId_t* id, object_id_t* objectId) {
if(tcDataLen < sizeof(object_id_t)) {
return CommandingServiceBase::INVALID_TC;
}
SerializeAdapter::deSerialize(objectId, &tcData,
&tcDataLen, SerializeIF::Endianness::BIG);
ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
return result;
}
ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
MessageQueueId_t * messageQueueToSet, object_id_t *objectId) {
DeviceHandlerIF* possibleTarget =
objectManager->get<DeviceHandlerIF>(*objectId);
if(possibleTarget == nullptr) {
return CommandingServiceBase::INVALID_OBJECT;
}
*messageQueueToSet = possibleTarget->getCommandQueue();
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
uint32_t* state, object_id_t objectId) {
switch(static_cast<Subservice>(subservice)){
case Subservice::RAW_COMMANDING: {
return prepareRawCommand(dynamic_cast<CommandMessage*>(message),
tcData, tcDataLen);
}
break;
case Subservice::TOGGLE_WIRETAPPING: {
return prepareWiretappingCommand(dynamic_cast<CommandMessage*>(message),
tcData, tcDataLen);
}
break;
default:
return HasReturnvaluesIF::RETURN_FAILED;
}
}
ReturnValue_t Service2DeviceAccess::prepareRawCommand(
CommandMessage* messageToSet, const uint8_t *tcData,size_t tcDataLen) {
RawCommand RawCommand(tcData,tcDataLen);
// store command into the Inter Process Communication Store
store_address_t storeAddress;
ReturnValue_t result = IPCStore->addData(&storeAddress,
RawCommand.getCommand(), RawCommand.getCommandSize());
DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet,
storeAddress);
return result;
}
ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand(
CommandMessage *messageToSet, const uint8_t *tcData,
size_t tcDataLen) {
if(tcDataLen != WiretappingToggle::WIRETAPPING_COMMAND_SIZE) {
return CommandingServiceBase::INVALID_TC;
}
WiretappingToggle command;
ReturnValue_t result = command.deSerialize(&tcData, &tcDataLen,
SerializeIF::Endianness::BIG);
DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(messageToSet,
command.getWiretappingMode());
return result;
}
ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply,
Command_t previousCommand, uint32_t* state,
CommandMessage* optionalNextCommand, object_id_t objectId,
bool* isStep) {
switch(reply->getCommand()) {
case CommandMessage::REPLY_COMMAND_OK:
return HasReturnvaluesIF::RETURN_OK;
case CommandMessage::REPLY_REJECTED:
return reply->getReplyRejectedReason();
default:
return CommandingServiceBase::INVALID_REPLY;
}
}
// All device handlers set service 2 as default raw receiver for wiretapping
// so we have to handle those unrequested messages.
void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
switch(reply->getCommand()) {
case DeviceHandlerMessage::REPLY_RAW_COMMAND:
sendWiretappingTm(reply,
static_cast<uint8_t>(Subservice::WIRETAPPING_RAW_TC));
break;
case DeviceHandlerMessage::REPLY_RAW_REPLY:
sendWiretappingTm(reply,
static_cast<uint8_t>(Subservice::RAW_REPLY));
break;
default:
sif::error << "Unknown message in Service2DeviceAccess::"
"handleUnrequestedReply with command ID " <<
reply->getCommand() << std::endl;
break;
}
//Must be reached by all cases to clear message
reply->clear();
}
void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
uint8_t subservice) {
// Raw Wiretapping
// Get Address of Data from Message
store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply);
const uint8_t* data = nullptr;
size_t size = 0;
ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
if(result != HasReturnvaluesIF::RETURN_OK){
sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
"handleUnrequestedReply with failure ID "<< result
<< std::endl;
return;
}
// Init our dummy packet and correct endianness of object ID before
// sending it back.
WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply),
data);
TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId);
sendTmPacket(subservice, TmPacket.data,size, reinterpret_cast<uint8_t*>(
&TmPacket.objectId), sizeof(TmPacket.objectId));
}
MessageQueueId_t Service2DeviceAccess::getDeviceQueue() {
return commandQueue->getId();
}

92
pus/Service2DeviceAccess.h Normal file
View File

@ -0,0 +1,92 @@
#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
#include <framework/objectmanager/SystemObjectIF.h>
#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
#include <framework/tmtcservices/CommandingServiceBase.h>
/**
* @brief Raw Commanding and Wiretapping of devices.
* @details
* Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
* Dissertation Baetz p. 115, 116, 165-167.
*
* This service provides the capability to communicate with devices in their
* native protocols with raw commands through the DeviceHandlerIF.
*
* This is a gateway service. It relays device commands to the software bus.
* This service is very closely tied to the CommandingServiceBase
* template class.
*
* There are 4 adaption points for component implementation through the
* CommandingServiceBase.
*
* This service employs custom subservices exclusively. This includes a
* wiretapping subservice to monitor all traffic between target devices and
* this service.
*
* - TC[2,128]: Raw Commanding
* - TC[2,129]: Toggle Wiretapping
* - TM[2,130]: Wiretapping Packet TM
* - TM[2,131]: Wiretapping Packet TC
* @ingroup pus_services
*/
class Service2DeviceAccess : public CommandingServiceBase,
public AcceptsDeviceResponsesIF
{
public:
Service2DeviceAccess(object_id_t objectId, uint16_t apid,
uint8_t serviceId, uint8_t numberOfParallelCommands = 4,
uint16_t commandTimeoutSeconds = 60);
virtual ~Service2DeviceAccess();
protected:
//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
ReturnValue_t isValidSubservice(uint8_t subservice) override;
ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
object_id_t *objectId) override;
ReturnValue_t prepareCommand(CommandMessage* message, uint8_t subservice,
const uint8_t *tcData, size_t tcDataLen, uint32_t *state,
object_id_t objectId) override;
ReturnValue_t handleReply(const CommandMessage* reply,
Command_t previousCommand, uint32_t *state,
CommandMessage* optionalNextCommand, object_id_t objectId,
bool *isStep) override;
/**
* @brief Generates TM packets containing either the TC wiretapping
* packets or the TM wiretapping packets.
* Note that for service 2, all telemetry will be treated as an
* unrequested reply regardless of wiretapping mode.
* @param reply
*/
void handleUnrequestedReply(CommandMessage* reply) override;
MessageQueueId_t getDeviceQueue() override;
private:
/**
* Generates TM packets for Wiretapping Service
* @param reply
* @param subservice
*/
void sendWiretappingTm(CommandMessage* reply,uint8_t subservice);
ReturnValue_t checkInterfaceAndAcquireMessageQueue(
MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
ReturnValue_t prepareRawCommand(CommandMessage* messageToSet,
const uint8_t* tcData, size_t tcDataLen);
ReturnValue_t prepareWiretappingCommand(CommandMessage* messageToSet,
const uint8_t* tcData, size_t tcDataLen);
enum class Subservice {
RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol
TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
};
};
#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */

91
pus/Service5EventReporting.cpp Normal file
View File

@ -0,0 +1,91 @@
#include <framework/pus/Service5EventReporting.h>
#include <framework/pus/servicepackets/Service5Packets.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
#include <framework/events/EventManagerIF.h>
#include <framework/ipc/QueueFactory.h>
#include <framework/tmtcpacket/pus/TmPacketStored.h>
Service5EventReporting::Service5EventReporting(object_id_t objectId,
uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
PusServiceBase(objectId, apid, serviceId),
maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
eventQueue = QueueFactory::instance()->createMessageQueue();
}
Service5EventReporting::~Service5EventReporting(){}
ReturnValue_t Service5EventReporting::performService() {
EventMessage message;
ReturnValue_t status = RETURN_OK;
for(uint8_t counter = 0;
counter < maxNumberReportsPerCycle;
counter++)
{
// Receive messages even if reporting is disabled for now.
status = eventQueue->receiveMessage(&message);
if(status == MessageQueueIF::EMPTY) {
return HasReturnvaluesIF::RETURN_OK;
}
if(enableEventReport) {
status = generateEventReport(message);
if(status != HasReturnvaluesIF::RETURN_OK) {
return status;
}
}
}
sif::debug << "Service5EventReporting::generateEventReport:"
" Too many events" << std::endl;
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t Service5EventReporting::generateEventReport(
EventMessage message)
{
EventReport report(message.getEventId(),message.getReporter(),
message.getParameter1(),message.getParameter2());
TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
message.getSeverity(), packetSubCounter++, &report);
ReturnValue_t result = tmPacket.sendPacket(
requestQueue->getDefaultDestination(),requestQueue->getId());
if(result != HasReturnvaluesIF::RETURN_OK) {
sif::debug << "Service5EventReporting::generateEventReport:"
" Could not send TM packet" << std::endl;
}
return result;
}
ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
switch(subservice) {
case Subservice::ENABLE: {
enableEventReport = true;
return HasReturnvaluesIF::RETURN_OK;
}
case Subservice::DISABLE: {
enableEventReport = false;
return HasReturnvaluesIF::RETURN_OK;
}
default:
return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
}
}
// In addition to the default PUSServiceBase initialization, this service needs
// to be registered to the event manager to listen for events.
ReturnValue_t Service5EventReporting::initialize() {
EventManagerIF* manager = objectManager->get<EventManagerIF>(
objects::EVENT_MANAGER);
if (manager == NULL) {
return RETURN_FAILED;
}
// register Service 5 as listener for events
ReturnValue_t result = manager->registerListener(eventQueue->getId(),true);
if(result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return PusServiceBase::initialize();
}

86
pus/Service5EventReporting.h Normal file
View File

@ -0,0 +1,86 @@
#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
#include <framework/tmtcservices/PusServiceBase.h>
#include <framework/events/EventMessage.h>
/**
* @brief Report on-board events like information or errors
* @details
* Full Documentation: ECSS-E70-41A p.79
* Implements the PusServiceBase template class.
* Documentation: Dissertation Baetz p.135,136
*
* This service provides for the reporting to the service user of information of
* operational significance.
* 1. reporting of failures or anomalies detected on-board;
* 2. reporting of autonomous on-board actions;
* 3. reporting of normal progress of operations and activities, e.g.
* detection of events which are not anomalous (such as payload events),
* reaching of predefined steps in an operation. Some reports can combine
* more than one of these events.
*
* Minimum capabilities of this service:
*
* - TM[5,1]: Normal/Progress Report
* - TM[5,2]: Error/Anomaly Report - Low Severity
* - TM[5,3]: Error/Anomaly Report - Medium Severity
* - TM[5,4]: Error/Anomaly Report - High Severity
*
* Events can be translated by using translator files located in
* /config/objects/ and /config/events/. Description to events can be added by
* adding a comment behind the event definition with [//!<] as leading string
*
* Additional capabilities of this service:
*
* - TC[5,5]: Enable Event Report Generation (Req. 6)
* - TC[5,6]: Disable Event Report Generation (Req. 5)
* @author R. Mueller
* @ingroup pus_services
*/
class Service5EventReporting: public PusServiceBase {
public:
Service5EventReporting(object_id_t objectId, uint16_t apid,
uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
virtual ~Service5EventReporting();
/***
* Check for events and generate event reports if required.
* @return
*/
ReturnValue_t performService() override;
/***
* Turn event generation on or off.
* @return
*/
ReturnValue_t handleRequest(uint8_t subservice) override;
/**
* The default PusServiceBase initialize has been overridden but is still
* executed. Registers this service as a listener for events at the
* EventManager.
* @return
*/
ReturnValue_t initialize() override;
enum Subservice: uint8_t {
NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report
ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity
ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity
ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity
ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation
DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation
};
private:
uint16_t packetSubCounter = 0;
MessageQueueIF* eventQueue = nullptr;
bool enableEventReport = true;
const uint8_t maxNumberReportsPerCycle;
ReturnValue_t generateEventReport(EventMessage message);
};
#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */

142
pus/Service8FunctionManagement.cpp Normal file
View File

@ -0,0 +1,142 @@
#include <framework/pus/Service8FunctionManagement.h>
#include <framework/pus/servicepackets/Service8Packets.h>
#include <framework/objectmanager/SystemObjectIF.h>
#include <framework/action/HasActionsIF.h>
#include <framework/devicehandlers/DeviceHandlerIF.h>
#include <framework/serialize/SerializeAdapter.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
uint16_t commandTimeoutSeconds):
CommandingServiceBase(object_id, apid, serviceId, numParallelCommands,
commandTimeoutSeconds) {}
Service8FunctionManagement::~Service8FunctionManagement() {}
ReturnValue_t Service8FunctionManagement::isValidSubservice(
uint8_t subservice) {
switch(static_cast<Subservice>(subservice)) {
case Subservice::DIRECT_COMMANDING:
return HasReturnvaluesIF::RETURN_OK;
default:
return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
}
}
ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject(
uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
MessageQueueId_t* id, object_id_t* objectId) {
if(tcDataLen < sizeof(object_id_t)) {
return CommandingServiceBase::INVALID_TC;
}
SerializeAdapter::deSerialize(objectId, &tcData,
&tcDataLen, SerializeIF::Endianness::BIG);
return checkInterfaceAndAcquireMessageQueue(id,objectId);
}
ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue(
MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
// check HasActionIF property of target
HasActionsIF* possibleTarget = objectManager->get<HasActionsIF>(*objectId);
if(possibleTarget == nullptr){
return CommandingServiceBase::INVALID_OBJECT;
}
*messageQueueToSet = possibleTarget->getCommandQueue();
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t Service8FunctionManagement::prepareCommand(
CommandMessage* message, uint8_t subservice, const uint8_t* tcData,
size_t tcDataLen, uint32_t* state, object_id_t objectId) {
return prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
tcData, tcDataLen);
}
ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
<< " TC size smaller thant minimum size of direct command."
<< std::endl;
return CommandingServiceBase::INVALID_TC;
}
// Create direct command instance by extracting data from Telecommand
DirectCommand command(tcData, tcDataLen);
// store additional parameters into the IPC Store
store_address_t parameterAddress;
ReturnValue_t result = IPCStore->addData(&parameterAddress,
command.getParameters(),command.getParametersSize());
// setCommand expects a Command Message, an Action ID and a store adress
// pointing to additional parameters
ActionMessage::setCommand(message,command.getActionId(),parameterAddress);
return result;
}
ReturnValue_t Service8FunctionManagement::handleReply(
const CommandMessage* reply, Command_t previousCommand,
uint32_t* state, CommandMessage* optionalNextCommand,
object_id_t objectId, bool* isStep) {
Command_t replyId = reply->getCommand();
ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
ActionId_t actionId = ActionMessage::getActionId(reply);
ReturnValue_t returnCode = ActionMessage::getReturnCode(reply);
switch(replyId) {
case ActionMessage::COMPLETION_SUCCESS: {
DirectReply completionReply(objectId, actionId,returnCode);
result = CommandingServiceBase::EXECUTION_COMPLETE;
break;
}
case ActionMessage::STEP_SUCCESS: {
*isStep = true;
result = HasReturnvaluesIF::RETURN_OK;
break;
}
case ActionMessage::DATA_REPLY: {
result = handleDataReply(reply, objectId, actionId);
break;
}
case ActionMessage::STEP_FAILED:
*isStep = true;
/*No break, falls through*/
case ActionMessage::COMPLETION_FAILED:
result = ActionMessage::getReturnCode(reply);
break;
default:
result = INVALID_REPLY;
}
return result;
}
ReturnValue_t Service8FunctionManagement::handleDataReply(
const CommandMessage* reply, object_id_t objectId,
ActionId_t actionId) {
store_address_t storeId = ActionMessage::getStoreId(reply);
size_t size = 0;
const uint8_t * buffer = nullptr;
ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
if(result != RETURN_OK) {
sif::error << "Service 8: Could not retrieve data for data reply"
<< std::endl;
return result;
}
DataReply dataReply(objectId, actionId, buffer, size);
result = sendTmPacket(static_cast<uint8_t>(
Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
auto deletionResult = IPCStore->deleteData(storeId);
if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
sif::warning << "Service8FunctionManagement::handleReply: Deletion"
<< " of data in pool failed." << std::endl;
}
return result;
}

67
pus/Service8FunctionManagement.h Normal file
View File

@ -0,0 +1,67 @@
#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
#include <framework/action/ActionMessage.h>
#include <framework/tmtcservices/CommandingServiceBase.h>
/**
* @brief Functional commanding.
* Full Documentation: ECSS-E-ST-70-41C p.64, p. 451
* Dissertation Baetz p. 115, 116, 165-167
*
* This service provides the capability to perform functions of an
* application process and provides high-level commanding as opposed to the
* Raw Access provided by Service 2. Examples for these functions can include
* control and operation of payload or the AOCS subsystem.
* This service will be the primary means to control the spacecraft as it is
* considered safer than the Raw Access provided
* by Service 2 and is generally sufficient for most tasks.
*
* This is a gateway service. It relays device commands using the software bus.
* This service is very closely tied to the Commanding Service Base template
* class. There is constant interaction between this Service Base und a
* subclass like this service.
*
* Service Capability:
* - TC[8,128]: Direct Commanding
* - TM[8,130]: Direct Commanding Data Reply
*
* @ingroup pus_services
*/
class Service8FunctionManagement : public CommandingServiceBase
{
public:
Service8FunctionManagement(object_id_t objectId, uint16_t apid,
uint8_t serviceId, uint8_t numParallelCommands = 4,
uint16_t commandTimeoutSeconds = 60);
virtual ~Service8FunctionManagement();
protected:
/* CSB abstract functions implementation . See CSB documentation. */
ReturnValue_t isValidSubservice(uint8_t subservice) override;
ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
object_id_t *objectId) override;
ReturnValue_t prepareCommand(CommandMessage* message,
uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
uint32_t *state, object_id_t objectId) override;
ReturnValue_t handleReply(const CommandMessage* reply,
Command_t previousCommand, uint32_t *state,
CommandMessage* optionalNextCommand, object_id_t objectId,
bool *isStep) override;
private:
enum class Subservice {
DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding
DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply
};
ReturnValue_t checkInterfaceAndAcquireMessageQueue(
MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
ReturnValue_t prepareDirectCommand(CommandMessage* message,
const uint8_t* tcData, size_t tcDataLen);
ReturnValue_t handleDataReply(const CommandMessage* reply,
object_id_t objectId, ActionId_t actionId);
};
#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */

166
pus/servicepackets/Service1Packets.h Normal file
View File

@ -0,0 +1,166 @@
/**
* @defgroup spacepackets PUS Packet Definitions
* This group contains all implemented TM or TM packages that are sent to
* or sent by the OBC.They are exported later to display
* packet structures in Mission Information Base (MIB).
*/
#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
#include <framework/serialize/SerializeAdapter.h>
#include <framework/tmtcservices/VerificationCodes.h>
/**
* @brief FailureReport class to serialize a failure report
* @brief Subservice 1, 3, 5, 7
* @ingroup spacepackets
*/
class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
public:
FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
uint16_t packetSequenceControl_, uint8_t stepNumber_,
ReturnValue_t errorCode_, uint32_t errorParameter1_,
uint32_t errorParameter2_) :
packetId(packetId_), packetSequenceControl(packetSequenceControl_),
stepNumber(stepNumber_), errorCode(errorCode_),
errorParameter1(errorParameter1_), errorParameter2(errorParameter2_),
failureSubtype(failureSubtype_) {}
/**
* This function is called by the FSFW when calling the tm packet send
* function and supplying the SerializeIF* as parameter
* @param buffer Object content is serialized into the buffer
* @param size
* @param max_size
* @param bigEndian
* @return
*/
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
size_t maxSize, SerializeIF::Endianness streamEndianness
) const override {
ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
result = SerializeAdapter::serialize(&stepNumber, buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
}
result = SerializeAdapter::serialize(&errorCode, buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::serialize(&errorParameter1, buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::serialize(&errorParameter2, buffer, size,
maxSize, streamEndianness);
return result;
}
virtual size_t getSerializedSize() const {
size_t size = 0;
size += SerializeAdapter::getSerializedSize(&packetId);
size += sizeof(packetSequenceControl);
if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
size += SerializeAdapter::getSerializedSize(&stepNumber);
}
size += SerializeAdapter::getSerializedSize(&errorCode);
size += SerializeAdapter::getSerializedSize(&errorParameter1);
size += SerializeAdapter::getSerializedSize(&errorParameter2);
return size;
}
/**
* Deserialization is not allowed for a report.
* @param buffer
* @param size
* @param bigEndian
* @return
*/
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
SerializeIF::Endianness streamEndianness) override {
return HasReturnvaluesIF::RETURN_FAILED;
}
private:
uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file
uint32_t errorParameter1;
uint32_t errorParameter2;
const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE]
};
/**
* @brief Subservices 2, 4, 6, 8
* @ingroup spacepackets
*/
class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
public:
SuccessReport(uint8_t subtype_, uint16_t packetId_,
uint16_t packetSequenceControl_,uint8_t stepNumber_) :
packetId(packetId_), packetSequenceControl(packetSequenceControl_),
stepNumber(stepNumber_), subtype(subtype_) {}
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
size_t maxSize, SerializeIF::Endianness streamEndianness
) const override {
ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
result = SerializeAdapter::serialize(&stepNumber, buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
}
return result;
}
virtual size_t getSerializedSize() const override {
size_t size = 0;
size += SerializeAdapter::getSerializedSize(&packetId);
size += sizeof(packetSequenceControl);
if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
size += SerializeAdapter::getSerializedSize(&stepNumber);
}
return size;
}
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
SerializeIF::Endianness streamEndianness) override {
return HasReturnvaluesIF::RETURN_FAILED;
}
private:
uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
const uint8_t subtype; //!< [EXPORT] : [IGNORE]
};
#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */

63
pus/servicepackets/Service200Packets.h Normal file
View File

@ -0,0 +1,63 @@
#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
#include <framework/serialize/SerialLinkedListAdapter.h>
#include <framework/modes/ModeMessage.h>
#include <framework/serialize/SerializeIF.h>
/**
* @brief Subservice 1, 2, 3, 4, 5
* @ingroup spacepackets
*/
class ModePacket : public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6
public:
ModePacket() {
setLinks();
}
ModePacket(object_id_t objectId, Mode_t mode, Submode_t submode) :
objectId(objectId), mode(mode), submode(submode) {
setLinks();
}
Mode_t getMode() {
return mode.entry;
}
Submode_t getSubmode() {
return submode.entry;
}
// Forbid copying, pointers are used.
ModePacket(const ModePacket&) = delete;
ModePacket& operator=(const ModePacket&) = delete;
private:
void setLinks() {
setStart(&objectId);
objectId.setNext(&mode);
mode.setNext(&submode);
}
SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Target or source object
SerializeElement<Mode_t> mode; //!< [EXPORT] : [COMMENT] 0: MODE_OFF, 1: MODE_ON, 2: MODE_NORMAL, 3: MODE_RAW
SerializeElement<Submode_t> submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible
};
/**
* @brief Subservice 7
* @ingroup spacepackets
*/
class CantReachModePacket: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 7
public:
CantReachModePacket(object_id_t objectId, ReturnValue_t reason):
objectId(objectId), reason(reason) {
setStart(&this->objectId);
this->objectId.setNext(&this->reason);
}
SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Reply source object
SerializeElement<ReturnValue_t> reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached
};
#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */

76
pus/servicepackets/Service2Packets.h Normal file
View File

@ -0,0 +1,76 @@
#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
#include <framework/action/ActionMessage.h>
#include <framework/objectmanager/SystemObjectIF.h>
#include <framework/serialize/SerialLinkedListAdapter.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
/**
* @brief Subservice 128
* @ingroup spacepackets
*/
class RawCommand { //!< [EXPORT] : [SUBSERVICE] 128
public:
RawCommand(const uint8_t* buffer, size_t size) {
// Deserialize Adapter to get correct endianness
SerializeAdapter::deSerialize(&objectId, &buffer, &size,
SerializeIF::Endianness::BIG);
commandBuffer = buffer;
// size is decremented by AutoSerializeAdapter,
// remaining size is data size
dataSize = size;
}
object_id_t getObjectId() const {
return objectId;
}
const uint8_t* getCommand() {
return commandBuffer;
}
size_t getCommandSize() const {
return dataSize;
}
private:
object_id_t objectId = 0;
const uint8_t* commandBuffer = nullptr; //!< [EXPORT] : [MAXSIZE] 256 Bytes
size_t dataSize = 0; //!< [EXPORT] : [IGNORE]
};
/**
* @brief Subservice 129: Command packet to set wiretapping mode
* @ingroup spacepackets
*/
class WiretappingToggle: public SerialLinkedListAdapter<SerializeIF>{ //!< [EXPORT] : [SUBSERVICE] 129
public:
static const size_t WIRETAPPING_COMMAND_SIZE = 5;
WiretappingToggle(){
setStart(&objectId);
objectId.setNext(&wiretappingMode);
}
uint8_t getWiretappingMode() const {
return wiretappingMode.entry;
}
private:
SerializeElement<object_id_t> objectId;
SerializeElement<uint8_t> wiretappingMode; //!< [EXPORT] : [INPUT] Mode 0: OFF, Mode 1: RAW
};
/**
* @brief Subservices 130 and 131: TM packets
* @ingroup spacepackets
*/
class WiretappingPacket { //!< [EXPORT] : [SUBSERVICE] 130, 131
public:
object_id_t objectId; //!< [EXPORT] : [COMMENT] Object ID of source object
const uint8_t* data; //!< [EXPORT] : [MAXSIZE] Raw Command Max. Size
WiretappingPacket(object_id_t objectId, const uint8_t* buffer):
objectId(objectId), data(buffer) {
}
};
#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */

76
pus/servicepackets/Service5Packets.h Normal file
View File

@ -0,0 +1,76 @@
#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
#include <framework/serialize/SerializeAdapter.h>
#include <framework/tmtcservices/VerificationCodes.h>
/**
* @brief Subservice 1, 2, 3, 4
* Structure of Event Report.
* It consists of:
* 1. Report ID(RID). This is the Event ID in the FSFW
* 2. Object ID of the reporter (e.g. subsystem)
* 2. Parameter 1
* 3. Parameter 2
*
* @ingroup spacepackets
*/
class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
public:
EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
uint32_t parameter2_):
reportId(reportId_),objectId(objectId_), parameter1(parameter1_),
parameter2(parameter2_) {}
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
size_t maxSize,
SerializeIF::Endianness streamEndianness) const override
{
ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer,
size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::serialize(&objectId, buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::serialize(&parameter1, buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::serialize(&parameter2, buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return result;
}
virtual size_t getSerializedSize() const override {
uint32_t size = 0;
size += SerializeAdapter::getSerializedSize(&reportId);
size += SerializeAdapter::getSerializedSize(&objectId);
size += SerializeAdapter::getSerializedSize(&parameter1);
size += SerializeAdapter::getSerializedSize(&parameter2);
return size;
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
SerializeIF::Endianness streamEndianness) override {
return HasReturnvaluesIF::RETURN_FAILED;
}
private:
EventId_t reportId;
object_id_t objectId;
uint32_t parameter1;
uint32_t parameter2;
};
#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */

121
pus/servicepackets/Service8Packets.h Normal file
View File

@ -0,0 +1,121 @@
#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
#include <framework/action/ActionMessage.h>
#include <framework/objectmanager/SystemObjectIF.h>
#include <framework/serialize/SerialBufferAdapter.h>
#include <framework/serialize/SerializeElement.h>
#include <framework/serialize/SerialLinkedListAdapter.h>
#include <framework/serialize/SerialFixedArrayListAdapter.h>
/**
* @brief Subservice 128
* @ingroup spacepackets
*/
class DirectCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
public:
DirectCommand(const uint8_t* tcData, size_t size) {
SerializeAdapter::deSerialize(&objectId, &tcData, &size,
SerializeIF::Endianness::BIG);
SerializeAdapter::deSerialize(&actionId, &tcData, &size,
SerializeIF::Endianness::BIG);
parameterBuffer = tcData;
parametersSize = size;
}
ActionId_t getActionId() const {
return actionId;
}
object_id_t getObjectId() const {
return objectId;
}
const uint8_t* getParameters() {
return parameterBuffer;
}
uint32_t getParametersSize() const {
return parametersSize;
}
private:
DirectCommand(const DirectCommand &command);
object_id_t objectId;
ActionId_t actionId;
uint32_t parametersSize; //!< [EXPORT] : [IGNORE]
const uint8_t * parameterBuffer; //!< [EXPORT] : [MAXSIZE] 65535 Bytes
};
/**
* @brief Subservice 130
* Data reply (subservice 130) consists of
* 1. Target Object ID
* 2. Action ID
* 3. Data
* @ingroup spacepackets
*/
class DataReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 130
public:
typedef uint16_t typeOfMaxDataSize;
static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
DataReply(object_id_t objectId_, ActionId_t actionId_,
const uint8_t * replyDataBuffer_ = NULL, uint16_t replyDataSize_ = 0):
objectId(objectId_), actionId(actionId_), replyData(replyDataBuffer_,replyDataSize_){
setLinks();
}
private:
DataReply(const DataReply &reply);
void setLinks() {
setStart(&objectId);
objectId.setNext(&actionId);
actionId.setNext(&replyData);
}
SerializeElement<object_id_t> objectId;
SerializeElement<ActionId_t> actionId;
SerializeElement<SerialBufferAdapter<uint16_t>> replyData;
};
/**
* @brief Subservice 132
* @details
* Not used yet. Telecommand Verification takes care of this.
* @ingroup spacepackets
*/
class DirectReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 132
public:
typedef uint16_t typeOfMaxDataSize;
static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
DirectReply(object_id_t objectId_, ActionId_t actionId_, ReturnValue_t returnCode_,
bool isStep_ = false, uint8_t step_ = 0):
isStep(isStep_), objectId(objectId_), actionId(actionId_),
returnCode(returnCode_),step(step_) {
setLinks();
}
private:
void setLinks() {
setStart(&objectId);
objectId.setNext(&actionId);
actionId.setNext(&returnCode);
if(isStep) {
returnCode.setNext(&step);
}
}
bool isStep; //!< [EXPORT] : [IGNORE]
SerializeElement<object_id_t> objectId; //!< [EXPORT] : [IGNORE]
SerializeElement<ActionId_t> actionId; //!< [EXPORT] : [IGNORE]
SerializeElement<ReturnValue_t> returnCode; //!< [EXPORT] : [IGNORE]
SerializeElement<uint8_t> step; //!< [EXPORT] : [OPTIONAL] [IGNORE]
};
#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */