mohr/fsfw
1
0
Fork 0
forked from fsfw/fsfw
Code Pull Requests Activity

lots of breaking some patching back together

Browse Source
This commit is contained in:
Ulrich Mohr 2023-06-20 15:14:15 +02:00
parent e831ba11d2
commit 1fc50a1562
13 changed files with 202 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/fsfw/action/Action.cpp
View File

@ -48,7 +48,8 @@ ReturnValue_t Action::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
ReturnValue_t Action::deSerialize(const uint8_t **buffer, size_t *size, ReturnValue_t Action::deSerialize(const uint8_t **buffer, size_t *size,
Endianness streamEndianness) { Endianness streamEndianness) {
ReturnValue_t result = returnvalue::OK;/* TODO not needed as must have been read before to find this action = SerializeAdapter::deSerialize(&id, buffer, size, streamEndianness); ReturnValue_t result = returnvalue::OK;/* TODO not needed as must have been read before to find this
action = SerializeAdapter::deSerialize(&id, buffer, size, streamEndianness);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
}*/ }*/

19
src/fsfw/action/ActionHelper.cpp
View File

@ -2,6 +2,7 @@
#include "fsfw/ipc/MessageQueueSenderIF.h" #include "fsfw/ipc/MessageQueueSenderIF.h"
#include "fsfw/objectmanager/ObjectManager.h" #include "fsfw/objectmanager/ObjectManager.h"
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/serviceinterface/ServiceInterface.h"
#include <fsfw/serialize/SerializeAdapter.h>
ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
: owner(setOwner), queueToUse(useThisQueue) {} : owner(setOwner), queueToUse(useThisQueue) {}
@ -67,14 +68,25 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, size_t offset,
ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size); ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
CommandMessage reply; CommandMessage reply;
ActionMessage::setStepReply(&reply, actionId, 0, result); ActionMessage::setStepReply(&reply, 0 /*TODO*/, 0, result);
queueToUse->sendMessage(commandedBy, &reply); queueToUse->sendMessage(commandedBy, &reply);
ipcStore->deleteData(dataAddress); ipcStore->deleteData(dataAddress);
return; return;
} }
//add offset, deserialize action dataPtr += offset;
size -=offset;
ActionId_t actionId;
result = SerializeAdapter::deSerialize(&actionId, &dataPtr, &size, SerializeIF::Endianness::NETWORK);
if (result != returnvalue::OK) {
CommandMessage reply;
ActionMessage::setStepReply(&reply, 0 /*TODO*/, 0, result);
queueToUse->sendMessage(commandedBy, &reply);
ipcStore->deleteData(dataAddress);
return;
}
auto actionIter = actionMap.find(actionId); auto actionIter = actionMap.find(actionId);
if (actionIter == actionMap.end()){ if (actionIter == actionMap.end()){
@ -85,8 +97,7 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, size_t offset,
return; return;
} }
Action* action = actionIter->second; Action* action = actionIter->second;
dataPtr +=6;
size -=6;
result = action->deSerialize(&dataPtr, &size, SerializeIF::Endianness::NETWORK); result = action->deSerialize(&dataPtr, &size, SerializeIF::Endianness::NETWORK);
if ((result != returnvalue::OK) || (size != 0)){ //TODO write unittest for second condition if ((result != returnvalue::OK) || (size != 0)){ //TODO write unittest for second condition
CommandMessage reply; CommandMessage reply;

16
src/fsfw/action/CommandActionHelper.cpp
View File

@ -74,24 +74,24 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
switch (reply->getCommand()) { switch (reply->getCommand()) {
case ActionMessage::COMPLETION_SUCCESS: case ActionMessage::COMPLETION_SUCCESS:
commandCount--; commandCount--;
owner->completionSuccessfulReceived(ActionMessage::getActionId(reply)); // owner->completionSuccessfulReceived(ActionMessage::getActionId(reply)); TODO
return returnvalue::OK; return returnvalue::OK;
case ActionMessage::COMPLETION_FAILED: case ActionMessage::COMPLETION_FAILED:
commandCount--; commandCount--;
owner->completionFailedReceived(ActionMessage::getActionId(reply), // owner->completionFailedReceived(ActionMessage::getActionId(reply),
ActionMessage::getReturnCode(reply)); // ActionMessage::getReturnCode(reply));
return returnvalue::OK; return returnvalue::OK;
case ActionMessage::STEP_SUCCESS: case ActionMessage::STEP_SUCCESS:
owner->stepSuccessfulReceived(ActionMessage::getActionId(reply), // owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
ActionMessage::getStep(reply)); // ActionMessage::getStep(reply));
return returnvalue::OK; return returnvalue::OK;
case ActionMessage::STEP_FAILED: case ActionMessage::STEP_FAILED:
commandCount--; commandCount--;
owner->stepFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getStep(reply), // owner->stepFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getStep(reply),
ActionMessage::getReturnCode(reply)); // ActionMessage::getReturnCode(reply));
return returnvalue::OK; return returnvalue::OK;
case ActionMessage::DATA_REPLY: case ActionMessage::DATA_REPLY:
extractDataForOwner(ActionMessage::getActionId(reply), ActionMessage::getStoreId(reply)); // extractDataForOwner(ActionMessage::getActionId(reply), ActionMessage::getStoreId(reply));
return returnvalue::OK; return returnvalue::OK;
default: default:
return returnvalue::FAILED; return returnvalue::FAILED;

3
src/fsfw/action/HasActionsIF.h
View File

@ -41,6 +41,9 @@ class HasActionsIF {
static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2); static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3); static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4); static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
enum class FUNCTIONS : uint8_t { EXECUTE_ACTION };
virtual ~HasActionsIF() = default; virtual ~HasActionsIF() = default;
/** /**
* Function to get the MessageQueueId_t of the implementing object * Function to get the MessageQueueId_t of the implementing object

24
src/fsfw/action/SimpleActionHelper.cpp
View File

@ -1,4 +1,6 @@
#include "fsfw/action.h" #include "fsfw/action.h"
#include <fsfw/serialize/SerializeAdapter.h>
SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
: ActionHelper(setOwner, useThisQueue), isExecuting(false) {} : ActionHelper(setOwner, useThisQueue), isExecuting(false) {}
@ -30,23 +32,39 @@ void SimpleActionHelper::resetHelper() {
lastCommander = 0; lastCommander = 0;
} }
void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy, size_t offset,
store_address_t dataAddress) { store_address_t dataAddress) {
CommandMessage reply; CommandMessage reply;
if (isExecuting) { if (isExecuting) {
ipcStore->deleteData(dataAddress); ipcStore->deleteData(dataAddress);
ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::IS_BUSY); ActionMessage::setStepReply(&reply, 0 /*TODO*/, 0, HasActionsIF::IS_BUSY);
queueToUse->sendMessage(commandedBy, &reply); queueToUse->sendMessage(commandedBy, &reply);
} }
const uint8_t* dataPtr = nullptr; const uint8_t* dataPtr = nullptr;
size_t size = 0; size_t size = 0;
ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size); ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
ActionMessage::setStepReply(&reply, 0 /*TODO*/, 0, result);
queueToUse->sendMessage(commandedBy, &reply);
ipcStore->deleteData(dataAddress);
return;
}
dataPtr += offset;
size -=offset;
ActionId_t actionId;
result = SerializeAdapter::deSerialize(&actionId, &dataPtr, &size, SerializeIF::Endianness::NETWORK);
if (result != returnvalue::OK) {
CommandMessage reply;
ActionMessage::setStepReply(&reply, actionId, 0, result); ActionMessage::setStepReply(&reply, actionId, 0, result);
queueToUse->sendMessage(commandedBy, &reply); queueToUse->sendMessage(commandedBy, &reply);
ipcStore->deleteData(dataAddress); ipcStore->deleteData(dataAddress);
return; return;
} }
auto actionIter = actionMap.find(actionId); auto actionIter = actionMap.find(actionId);
if (actionIter == actionMap.end()){ if (actionIter == actionMap.end()){
CommandMessage reply; CommandMessage reply;

4
src/fsfw/action/SimpleActionHelper.h
View File

@ -17,8 +17,8 @@ class SimpleActionHelper : public ActionHelper {
ReturnValue_t reportData(SerializeIF* data); ReturnValue_t reportData(SerializeIF* data);
protected: protected:
void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, virtual void prepareExecution(MessageQueueId_t commandedBy, size_t offset,
store_address_t dataAddress) override; store_address_t dataAddress) override;
void resetHelper() override; void resetHelper() override;
private: private:

2
src/fsfw/pus/CMakeLists.txt
View File

@ -4,7 +4,7 @@ target_sources(
Service2DeviceAccess.cpp Service2DeviceAccess.cpp
Service3Housekeeping.cpp Service3Housekeeping.cpp
Service5EventReporting.cpp Service5EventReporting.cpp
Service8FunctionManagement.cpp #Service8FunctionManagement.cpp
Service9TimeManagement.cpp Service9TimeManagement.cpp
Service17Test.cpp Service17Test.cpp
Service20ParameterManagement.cpp Service20ParameterManagement.cpp

108
src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp
View File

@ -53,11 +53,11 @@ ReturnValue_t GyroHandlerL3GD20H::buildTransitionDeviceCommand(DeviceCommandId_t
command[2] = L3GD20H::CTRL_REG_3_VAL; command[2] = L3GD20H::CTRL_REG_3_VAL;
command[3] = L3GD20H::CTRL_REG_4_VAL; command[3] = L3GD20H::CTRL_REG_4_VAL;
command[4] = L3GD20H::CTRL_REG_5_VAL; command[4] = L3GD20H::CTRL_REG_5_VAL;
return buildCommandFromCommand(*id, command, 5); return 0;//buildCommandFromCommand(*id, command, 5);
} }
case (InternalState::CHECK_REGS): { case (InternalState::CHECK_REGS): {
*id = L3GD20H::READ_REGS; *id = L3GD20H::READ_REGS;
return buildCommandFromCommand(*id, nullptr, 0); return 0;//buildCommandFromCommand(*id, nullptr, 0);
} }
default: default:
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
@ -77,66 +77,66 @@ ReturnValue_t GyroHandlerL3GD20H::buildTransitionDeviceCommand(DeviceCommandId_t
ReturnValue_t GyroHandlerL3GD20H::buildNormalDeviceCommand(DeviceCommandId_t *id) { ReturnValue_t GyroHandlerL3GD20H::buildNormalDeviceCommand(DeviceCommandId_t *id) {
*id = L3GD20H::READ_REGS; *id = L3GD20H::READ_REGS;
return buildCommandFromCommand(*id, nullptr, 0); return 0;//buildCommandFromCommand(*id, nullptr, 0);
} }
ReturnValue_t GyroHandlerL3GD20H::buildCommandFromCommand(DeviceCommandId_t deviceCommand, // ReturnValue_t GyroHandlerL3GD20H::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
const uint8_t *commandData, // const uint8_t *commandData,
size_t commandDataLen) { // size_t commandDataLen) {
switch (deviceCommand) { // switch (deviceCommand) {
case (L3GD20H::READ_REGS): { // case (L3GD20H::READ_REGS): {
commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK | L3GD20H::READ_MASK; // commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK | L3GD20H::READ_MASK;
std::memset(commandBuffer + 1, 0, L3GD20H::READ_LEN); // std::memset(commandBuffer + 1, 0, L3GD20H::READ_LEN);
rawPacket = commandBuffer; // rawPacket = commandBuffer;
rawPacketLen = L3GD20H::READ_LEN + 1; // rawPacketLen = L3GD20H::READ_LEN + 1;
break; // break;
} // }
case (L3GD20H::CONFIGURE_CTRL_REGS): { // case (L3GD20H::CONFIGURE_CTRL_REGS): {
commandBuffer[0] = L3GD20H::CTRL_REG_1 | L3GD20H::AUTO_INCREMENT_MASK; // commandBuffer[0] = L3GD20H::CTRL_REG_1 | L3GD20H::AUTO_INCREMENT_MASK;
if (commandData == nullptr or commandDataLen != 5) { // if (commandData == nullptr or commandDataLen != 5) {
return DeviceHandlerIF::INVALID_COMMAND_PARAMETER; // return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
} // }
ctrlReg1Value = commandData[0]; // ctrlReg1Value = commandData[0];
ctrlReg2Value = commandData[1]; // ctrlReg2Value = commandData[1];
ctrlReg3Value = commandData[2]; // ctrlReg3Value = commandData[2];
ctrlReg4Value = commandData[3]; // ctrlReg4Value = commandData[3];
ctrlReg5Value = commandData[4]; // ctrlReg5Value = commandData[4];
bool fsH = ctrlReg4Value & L3GD20H::SET_FS_1; // bool fsH = ctrlReg4Value & L3GD20H::SET_FS_1;
bool fsL = ctrlReg4Value & L3GD20H::SET_FS_0; // bool fsL = ctrlReg4Value & L3GD20H::SET_FS_0;
if (not fsH and not fsL) { // if (not fsH and not fsL) {
sensitivity = L3GD20H::SENSITIVITY_00; // sensitivity = L3GD20H::SENSITIVITY_00;
} else if (not fsH and fsL) { // } else if (not fsH and fsL) {
sensitivity = L3GD20H::SENSITIVITY_01; // sensitivity = L3GD20H::SENSITIVITY_01;
} else { // } else {
sensitivity = L3GD20H::SENSITIVITY_11; // sensitivity = L3GD20H::SENSITIVITY_11;
} // }
commandBuffer[1] = ctrlReg1Value; // commandBuffer[1] = ctrlReg1Value;
commandBuffer[2] = ctrlReg2Value; // commandBuffer[2] = ctrlReg2Value;
commandBuffer[3] = ctrlReg3Value; // commandBuffer[3] = ctrlReg3Value;
commandBuffer[4] = ctrlReg4Value; // commandBuffer[4] = ctrlReg4Value;
commandBuffer[5] = ctrlReg5Value; // commandBuffer[5] = ctrlReg5Value;
rawPacket = commandBuffer; // rawPacket = commandBuffer;
rawPacketLen = 6; // rawPacketLen = 6;
break; // break;
} // }
case (L3GD20H::READ_CTRL_REGS): { // case (L3GD20H::READ_CTRL_REGS): {
commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK | L3GD20H::READ_MASK; // commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK | L3GD20H::READ_MASK;
std::memset(commandBuffer + 1, 0, 5); // std::memset(commandBuffer + 1, 0, 5);
rawPacket = commandBuffer; // rawPacket = commandBuffer;
rawPacketLen = 6; // rawPacketLen = 6;
break; // break;
} // }
default: // default:
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED; // return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
} // }
return returnvalue::OK; // return returnvalue::OK;
} //}
ReturnValue_t GyroHandlerL3GD20H::scanForReply(const uint8_t *start, size_t len, ReturnValue_t GyroHandlerL3GD20H::scanForReply(const uint8_t *start, size_t len,
DeviceCommandId_t *foundId, size_t *foundLen) { DeviceCommandId_t *foundId, size_t *foundLen) {

4
src/fsfw_hal/devicehandlers/GyroL3GD20Handler.h
View File

@ -43,8 +43,8 @@ class GyroHandlerL3GD20H : public DeviceHandlerBase {
void doStartUp() override; void doStartUp() override;
void doShutDown() override; void doShutDown() override;
ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override; ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData, // ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
size_t commandDataLen) override; // size_t commandDataLen) override;
ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId, ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
size_t *foundLen) override; size_t *foundLen) override;
virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override; virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;

78
src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp
View File

@ -85,7 +85,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(DeviceCommandId_t
return returnvalue::OK; return returnvalue::OK;
} }
} }
return buildCommandFromCommand(*id, NULL, 0); return 0;//buildCommandFromCommand(*id, NULL, 0);
} }
uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) { uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) {
@ -119,52 +119,52 @@ ReturnValue_t MgmLIS3MDLHandler::buildNormalDeviceCommand(DeviceCommandId_t *id)
if (communicationStep == CommunicationStep::DATA) { if (communicationStep == CommunicationStep::DATA) {
*id = MGMLIS3MDL::READ_CONFIG_AND_DATA; *id = MGMLIS3MDL::READ_CONFIG_AND_DATA;
communicationStep = CommunicationStep::TEMPERATURE; communicationStep = CommunicationStep::TEMPERATURE;
return buildCommandFromCommand(*id, NULL, 0); return 0;//buildCommandFromCommand(*id, NULL, 0);
} else { } else {
*id = MGMLIS3MDL::READ_TEMPERATURE; *id = MGMLIS3MDL::READ_TEMPERATURE;
communicationStep = CommunicationStep::DATA; communicationStep = CommunicationStep::DATA;
return buildCommandFromCommand(*id, NULL, 0); return 0;//buildCommandFromCommand(*id, NULL, 0);
} }
} }
ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand, // ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
const uint8_t *commandData, // const uint8_t *commandData,
size_t commandDataLen) { // size_t commandDataLen) {
switch (deviceCommand) { // switch (deviceCommand) {
case (MGMLIS3MDL::READ_CONFIG_AND_DATA): { // case (MGMLIS3MDL::READ_CONFIG_AND_DATA): {
std::memset(commandBuffer, 0, sizeof(commandBuffer)); // std::memset(commandBuffer, 0, sizeof(commandBuffer));
commandBuffer[0] = readCommand(MGMLIS3MDL::CTRL_REG1, true); // commandBuffer[0] = readCommand(MGMLIS3MDL::CTRL_REG1, true);
rawPacket = commandBuffer; // rawPacket = commandBuffer;
rawPacketLen = MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1; // rawPacketLen = MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1;
return returnvalue::OK; // return returnvalue::OK;
} // }
case (MGMLIS3MDL::READ_TEMPERATURE): { // case (MGMLIS3MDL::READ_TEMPERATURE): {
std::memset(commandBuffer, 0, 3); // std::memset(commandBuffer, 0, 3);
commandBuffer[0] = readCommand(MGMLIS3MDL::TEMP_LOWBYTE, true); // commandBuffer[0] = readCommand(MGMLIS3MDL::TEMP_LOWBYTE, true);
rawPacket = commandBuffer; // rawPacket = commandBuffer;
rawPacketLen = 3; // rawPacketLen = 3;
return returnvalue::OK; // return returnvalue::OK;
} // }
case (MGMLIS3MDL::IDENTIFY_DEVICE): { // case (MGMLIS3MDL::IDENTIFY_DEVICE): {
return identifyDevice(); // return identifyDevice();
} // }
case (MGMLIS3MDL::TEMP_SENSOR_ENABLE): { // case (MGMLIS3MDL::TEMP_SENSOR_ENABLE): {
return enableTemperatureSensor(commandData, commandDataLen); // return enableTemperatureSensor(commandData, commandDataLen);
} // }
case (MGMLIS3MDL::SETUP_MGM): { // case (MGMLIS3MDL::SETUP_MGM): {
setupMgm(); // setupMgm();
return returnvalue::OK; // return returnvalue::OK;
} // }
case (MGMLIS3MDL::ACCURACY_OP_MODE_SET): { // case (MGMLIS3MDL::ACCURACY_OP_MODE_SET): {
return setOperatingMode(commandData, commandDataLen); // return setOperatingMode(commandData, commandDataLen);
} // }
default: // default:
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED; // return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
} // }
return returnvalue::FAILED; // return returnvalue::FAILED;
} // }
ReturnValue_t MgmLIS3MDLHandler::identifyDevice() { ReturnValue_t MgmLIS3MDLHandler::identifyDevice() {
uint32_t size = 2; uint32_t size = 2;

4
src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
View File

@ -46,8 +46,8 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
void doStartUp() override; void doStartUp() override;
void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override; void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
virtual uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override; virtual uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData, // ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
size_t commandDataLen) override; // size_t commandDataLen) override;
ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override; ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override; ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId, ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,

102
src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp
View File

@ -96,62 +96,62 @@ ReturnValue_t MgmRM3100Handler::buildTransitionDeviceCommand(DeviceCommandId_t *
return returnvalue::OK; return returnvalue::OK;
} }
return buildCommandFromCommand(*id, commandBuffer, commandLen); return 0;//buildCommandFromCommand(*id, commandBuffer, commandLen);
} }
ReturnValue_t MgmRM3100Handler::buildCommandFromCommand(DeviceCommandId_t deviceCommand, // ReturnValue_t MgmRM3100Handler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
const uint8_t *commandData, // const uint8_t *commandData,
size_t commandDataLen) { // size_t commandDataLen) {
switch (deviceCommand) { // switch (deviceCommand) {
case (RM3100::CONFIGURE_CMM): { // case (RM3100::CONFIGURE_CMM): {
commandBuffer[0] = RM3100::CMM_REGISTER; // commandBuffer[0] = RM3100::CMM_REGISTER;
commandBuffer[1] = RM3100::CMM_VALUE; // commandBuffer[1] = RM3100::CMM_VALUE;
rawPacket = commandBuffer; // rawPacket = commandBuffer;
rawPacketLen = 2; // rawPacketLen = 2;
break; // break;
} // }
case (RM3100::READ_CMM): { // case (RM3100::READ_CMM): {
commandBuffer[0] = RM3100::CMM_REGISTER | RM3100::READ_MASK; // commandBuffer[0] = RM3100::CMM_REGISTER | RM3100::READ_MASK;
commandBuffer[1] = 0; // commandBuffer[1] = 0;
rawPacket = commandBuffer; // rawPacket = commandBuffer;
rawPacketLen = 2; // rawPacketLen = 2;
break; // break;
} // }
case (RM3100::CONFIGURE_TMRC): { // case (RM3100::CONFIGURE_TMRC): {
return handleTmrcConfigCommand(deviceCommand, commandData, commandDataLen); // return handleTmrcConfigCommand(deviceCommand, commandData, commandDataLen);
} // }
case (RM3100::READ_TMRC): { // case (RM3100::READ_TMRC): {
commandBuffer[0] = RM3100::TMRC_REGISTER | RM3100::READ_MASK; // commandBuffer[0] = RM3100::TMRC_REGISTER | RM3100::READ_MASK;
commandBuffer[1] = 0; // commandBuffer[1] = 0;
rawPacket = commandBuffer; // rawPacket = commandBuffer;
rawPacketLen = 2; // rawPacketLen = 2;
break; // break;
} // }
case (RM3100::CONFIGURE_CYCLE_COUNT): { // case (RM3100::CONFIGURE_CYCLE_COUNT): {
return handleCycleCountConfigCommand(deviceCommand, commandData, commandDataLen); // return handleCycleCountConfigCommand(deviceCommand, commandData, commandDataLen);
} // }
case (RM3100::READ_CYCLE_COUNT): { // case (RM3100::READ_CYCLE_COUNT): {
commandBuffer[0] = RM3100::CYCLE_COUNT_START_REGISTER | RM3100::READ_MASK; // commandBuffer[0] = RM3100::CYCLE_COUNT_START_REGISTER | RM3100::READ_MASK;
std::memset(commandBuffer + 1, 0, 6); // std::memset(commandBuffer + 1, 0, 6);
rawPacket = commandBuffer; // rawPacket = commandBuffer;
rawPacketLen = 7; // rawPacketLen = 7;
break; // break;
} // }
case (RM3100::READ_DATA): { // case (RM3100::READ_DATA): {
commandBuffer[0] = RM3100::MEASUREMENT_REG_START | RM3100::READ_MASK; // commandBuffer[0] = RM3100::MEASUREMENT_REG_START | RM3100::READ_MASK;
std::memset(commandBuffer + 1, 0, 9); // std::memset(commandBuffer + 1, 0, 9);
rawPacketLen = 10; // rawPacketLen = 10;
break; // break;
} // }
default: // default:
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED; // return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
} // }
return returnvalue::OK; // return returnvalue::OK;
} // }
ReturnValue_t MgmRM3100Handler::buildNormalDeviceCommand(DeviceCommandId_t *id) { ReturnValue_t MgmRM3100Handler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
*id = RM3100::READ_DATA; *id = RM3100::READ_DATA;
return buildCommandFromCommand(*id, nullptr, 0); return 0;//buildCommandFromCommand(*id, nullptr, 0);
} }
ReturnValue_t MgmRM3100Handler::scanForReply(const uint8_t *start, size_t len, ReturnValue_t MgmRM3100Handler::scanForReply(const uint8_t *start, size_t len,

4
src/fsfw_hal/devicehandlers/MgmRM3100Handler.h
View File

@ -42,8 +42,8 @@ class MgmRM3100Handler : public DeviceHandlerBase {
void doStartUp() override; void doStartUp() override;
void doShutDown() override; void doShutDown() override;
ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override; ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData, // ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
size_t commandDataLen) override; // size_t commandDataLen) override;
ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId, ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
size_t *foundLen) override; size_t *foundLen) override;
ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override; ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;