added new pus services
This commit is contained in:
parent
5fb5cea949
commit
6b2b788308
13
framework.mk
13
framework.mk
@ -1,5 +1,5 @@
|
||||
# This file needs FRAMEWORK_PATH and API set correctly
|
||||
# Valid API settings: rtems, linux, freeRTOS
|
||||
# This file needs FRAMEWORK_PATH and OS_FSFW set correctly by another Makefile.
|
||||
# Valid API settings: rtems, linux, freeRTOS, host
|
||||
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/action/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/container/*.cpp)
|
||||
@ -8,11 +8,13 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/controller/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoolglob/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/eventmatching/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/fdir/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/framework.mk/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/matching/*.cpp)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/math/*.cpp)
|
||||
@ -32,8 +34,10 @@ else ifeq ($(OS),linux)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/linux/*.cpp)
|
||||
else ifeq ($(OS),freeRTOS)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
|
||||
else ifeq ($(OS),host)
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
|
||||
else
|
||||
$(error invalid OS specified, valid OS are rtems, linux, freeRTOS)
|
||||
$(error invalid OS specified, valid OS are rtems, linux, freeRTOS, host)
|
||||
endif
|
||||
|
||||
CXXSRC += $(wildcard $(FRAMEWORK_PATH)/parameters/*.cpp)
|
||||
@ -54,3 +58,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
119
pus/CService200ModeCommanding.cpp
Normal 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
85
pus/CService200ModeCommanding.h
Normal 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
100
pus/Service1TelecommandVerification.cpp
Normal 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
94
pus/Service1TelecommandVerification.h
Normal 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
167
pus/Service2DeviceAccess.cpp
Normal 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
92
pus/Service2DeviceAccess.h
Normal 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
91
pus/Service5EventReporting.cpp
Normal 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
86
pus/Service5EventReporting.h
Normal 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_ */
|
||||
135
pus/Service8FunctionManagement.cpp
Normal file
135
pus/Service8FunctionManagement.cpp
Normal file
@ -0,0 +1,135 @@
|
||||
#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) {
|
||||
// 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(¶meterAddress,
|
||||
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
67
pus/Service8FunctionManagement.h
Normal 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
166
pus/servicepackets/Service1Packets.h
Normal 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
63
pus/servicepackets/Service200Packets.h
Normal 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
76
pus/servicepackets/Service2Packets.h
Normal 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
76
pus/servicepackets/Service5Packets.h
Normal 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(¶meter1, buffer, size,
|
||||
maxSize, streamEndianness);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = SerializeAdapter::serialize(¶meter2, 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(¶meter1);
|
||||
size += SerializeAdapter::getSerializedSize(¶meter2);
|
||||
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_ */
|
||||
136
pus/servicepackets/Service8Packets.h
Normal file
136
pus/servicepackets/Service8Packets.h
Normal file
@ -0,0 +1,136 @@
|
||||
/**
|
||||
* \file Service8Packets.h
|
||||
*
|
||||
* \brief Structure of a Direct Command.
|
||||
* Normal reply (subservice 130) consists of
|
||||
* 1. Target object ID
|
||||
* 2. Action ID (taget device has specified functions with action IDs)
|
||||
* 3. Return Code
|
||||
* 4. Optional step number for step replies
|
||||
*
|
||||
* Data reply (subservice 132) consists of
|
||||
* 1. Target Object ID
|
||||
* 2. Action ID
|
||||
* 3. Data
|
||||
*
|
||||
* \date 01.07.2019
|
||||
* \author R. Mueller
|
||||
*/
|
||||
|
||||
#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:
|
||||
//typedef uint16_t typeOfMaxData;
|
||||
//static const typeOfMaxData MAX_DATA = 256;
|
||||
DirectCommand(const uint8_t* dataBuffer_, uint32_t size_) {
|
||||
size_t size = sizeof(objectId);
|
||||
SerializeAdapter::deSerialize(&objectId,&dataBuffer_,&size,
|
||||
SerializeIF::Endianness::BIG);
|
||||
size = sizeof(actionId);
|
||||
SerializeAdapter::deSerialize(&actionId,&dataBuffer_,&size,
|
||||
SerializeIF::Endianness::BIG);
|
||||
parameterBuffer = dataBuffer_;
|
||||
parametersSize = size_ - sizeof(objectId) - sizeof(actionId);
|
||||
}
|
||||
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
|
||||
* \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
|
||||
* \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 isDataReply; //!< [EXPORT] : [IGNORE]
|
||||
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_ */
|
||||
Loading…
Reference in New Issue
Block a user