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,
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) {
return result;
}*/

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

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

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

@ -74,24 +74,24 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
switch (reply->getCommand()) {
case ActionMessage::COMPLETION_SUCCESS:
commandCount--;
owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
// owner->completionSuccessfulReceived(ActionMessage::getActionId(reply)); TODO
return returnvalue::OK;
case ActionMessage::COMPLETION_FAILED:
commandCount--;
owner->completionFailedReceived(ActionMessage::getActionId(reply),
ActionMessage::getReturnCode(reply));
// owner->completionFailedReceived(ActionMessage::getActionId(reply),
// ActionMessage::getReturnCode(reply));
return returnvalue::OK;
case ActionMessage::STEP_SUCCESS:
owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
ActionMessage::getStep(reply));
// owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
// ActionMessage::getStep(reply));
return returnvalue::OK;
case ActionMessage::STEP_FAILED:
commandCount--;
owner->stepFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getStep(reply),
ActionMessage::getReturnCode(reply));
// owner->stepFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getStep(reply),
// ActionMessage::getReturnCode(reply));
return returnvalue::OK;
case ActionMessage::DATA_REPLY:
extractDataForOwner(ActionMessage::getActionId(reply), ActionMessage::getStoreId(reply));
// extractDataForOwner(ActionMessage::getActionId(reply), ActionMessage::getStoreId(reply));
return returnvalue::OK;
default:
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 EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
enum class FUNCTIONS : uint8_t { EXECUTE_ACTION };
virtual ~HasActionsIF() = default;
/**
* Function to get the MessageQueueId_t of the implementing object

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

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

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

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

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

@ -4,7 +4,7 @@ target_sources(
Service2DeviceAccess.cpp
Service3Housekeeping.cpp
Service5EventReporting.cpp
Service8FunctionManagement.cpp
#Service8FunctionManagement.cpp
Service9TimeManagement.cpp
Service17Test.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[3] = L3GD20H::CTRL_REG_4_VAL;
command[4] = L3GD20H::CTRL_REG_5_VAL;
return buildCommandFromCommand(*id, command, 5);
return 0;//buildCommandFromCommand(*id, command, 5);
}
case (InternalState::CHECK_REGS): {
*id = L3GD20H::READ_REGS;
return buildCommandFromCommand(*id, nullptr, 0);
return 0;//buildCommandFromCommand(*id, nullptr, 0);
}
default:
#if FSFW_CPP_OSTREAM_ENABLED == 1
@ -77,66 +77,66 @@ ReturnValue_t GyroHandlerL3GD20H::buildTransitionDeviceCommand(DeviceCommandId_t
ReturnValue_t GyroHandlerL3GD20H::buildNormalDeviceCommand(DeviceCommandId_t *id) {
*id = L3GD20H::READ_REGS;
return buildCommandFromCommand(*id, nullptr, 0);
return 0;//buildCommandFromCommand(*id, nullptr, 0);
}
ReturnValue_t GyroHandlerL3GD20H::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
const uint8_t *commandData,
size_t commandDataLen) {
switch (deviceCommand) {
case (L3GD20H::READ_REGS): {
commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK | L3GD20H::READ_MASK;
std::memset(commandBuffer + 1, 0, L3GD20H::READ_LEN);
rawPacket = commandBuffer;
rawPacketLen = L3GD20H::READ_LEN + 1;
break;
}
case (L3GD20H::CONFIGURE_CTRL_REGS): {
commandBuffer[0] = L3GD20H::CTRL_REG_1 | L3GD20H::AUTO_INCREMENT_MASK;
if (commandData == nullptr or commandDataLen != 5) {
return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
}
// ReturnValue_t GyroHandlerL3GD20H::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
// const uint8_t *commandData,
// size_t commandDataLen) {
// switch (deviceCommand) {
// case (L3GD20H::READ_REGS): {
// commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK | L3GD20H::READ_MASK;
// std::memset(commandBuffer + 1, 0, L3GD20H::READ_LEN);
// rawPacket = commandBuffer;
// rawPacketLen = L3GD20H::READ_LEN + 1;
// break;
// }
// case (L3GD20H::CONFIGURE_CTRL_REGS): {
// commandBuffer[0] = L3GD20H::CTRL_REG_1 | L3GD20H::AUTO_INCREMENT_MASK;
// if (commandData == nullptr or commandDataLen != 5) {
// return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
// }
ctrlReg1Value = commandData[0];
ctrlReg2Value = commandData[1];
ctrlReg3Value = commandData[2];
ctrlReg4Value = commandData[3];
ctrlReg5Value = commandData[4];
// ctrlReg1Value = commandData[0];
// ctrlReg2Value = commandData[1];
// ctrlReg3Value = commandData[2];
// ctrlReg4Value = commandData[3];
// ctrlReg5Value = commandData[4];
bool fsH = ctrlReg4Value & L3GD20H::SET_FS_1;
bool fsL = ctrlReg4Value & L3GD20H::SET_FS_0;
// bool fsH = ctrlReg4Value & L3GD20H::SET_FS_1;
// bool fsL = ctrlReg4Value & L3GD20H::SET_FS_0;
if (not fsH and not fsL) {
sensitivity = L3GD20H::SENSITIVITY_00;
} else if (not fsH and fsL) {
sensitivity = L3GD20H::SENSITIVITY_01;
} else {
sensitivity = L3GD20H::SENSITIVITY_11;
}
// if (not fsH and not fsL) {
// sensitivity = L3GD20H::SENSITIVITY_00;
// } else if (not fsH and fsL) {
// sensitivity = L3GD20H::SENSITIVITY_01;
// } else {
// sensitivity = L3GD20H::SENSITIVITY_11;
// }
commandBuffer[1] = ctrlReg1Value;
commandBuffer[2] = ctrlReg2Value;
commandBuffer[3] = ctrlReg3Value;
commandBuffer[4] = ctrlReg4Value;
commandBuffer[5] = ctrlReg5Value;
// commandBuffer[1] = ctrlReg1Value;
// commandBuffer[2] = ctrlReg2Value;
// commandBuffer[3] = ctrlReg3Value;
// commandBuffer[4] = ctrlReg4Value;
// commandBuffer[5] = ctrlReg5Value;
rawPacket = commandBuffer;
rawPacketLen = 6;
break;
}
case (L3GD20H::READ_CTRL_REGS): {
commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK | L3GD20H::READ_MASK;
// rawPacket = commandBuffer;
// rawPacketLen = 6;
// break;
// }
// case (L3GD20H::READ_CTRL_REGS): {
// commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK | L3GD20H::READ_MASK;
std::memset(commandBuffer + 1, 0, 5);
rawPacket = commandBuffer;
rawPacketLen = 6;
break;
}
default:
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
}
return returnvalue::OK;
}
// std::memset(commandBuffer + 1, 0, 5);
// rawPacket = commandBuffer;
// rawPacketLen = 6;
// break;
// }
// default:
// return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
// }
// return returnvalue::OK;
//}
ReturnValue_t GyroHandlerL3GD20H::scanForReply(const uint8_t *start, size_t len,
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 doShutDown() override;
ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
size_t commandDataLen) override;
// ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
// size_t commandDataLen) override;
ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
size_t *foundLen) 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 buildCommandFromCommand(*id, NULL, 0);
return 0;//buildCommandFromCommand(*id, NULL, 0);
}
uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) {
@ -119,52 +119,52 @@ ReturnValue_t MgmLIS3MDLHandler::buildNormalDeviceCommand(DeviceCommandId_t *id)
if (communicationStep == CommunicationStep::DATA) {
*id = MGMLIS3MDL::READ_CONFIG_AND_DATA;
communicationStep = CommunicationStep::TEMPERATURE;
return buildCommandFromCommand(*id, NULL, 0);
return 0;//buildCommandFromCommand(*id, NULL, 0);
} else {
*id = MGMLIS3MDL::READ_TEMPERATURE;
communicationStep = CommunicationStep::DATA;
return buildCommandFromCommand(*id, NULL, 0);
return 0;//buildCommandFromCommand(*id, NULL, 0);
}
}
ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
const uint8_t *commandData,
size_t commandDataLen) {
switch (deviceCommand) {
case (MGMLIS3MDL::READ_CONFIG_AND_DATA): {
std::memset(commandBuffer, 0, sizeof(commandBuffer));
commandBuffer[0] = readCommand(MGMLIS3MDL::CTRL_REG1, true);
// ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
// const uint8_t *commandData,
// size_t commandDataLen) {
// switch (deviceCommand) {
// case (MGMLIS3MDL::READ_CONFIG_AND_DATA): {
// std::memset(commandBuffer, 0, sizeof(commandBuffer));
// commandBuffer[0] = readCommand(MGMLIS3MDL::CTRL_REG1, true);
rawPacket = commandBuffer;
rawPacketLen = MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1;
return returnvalue::OK;
}
case (MGMLIS3MDL::READ_TEMPERATURE): {
std::memset(commandBuffer, 0, 3);
commandBuffer[0] = readCommand(MGMLIS3MDL::TEMP_LOWBYTE, true);
// rawPacket = commandBuffer;
// rawPacketLen = MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1;
// return returnvalue::OK;
// }
// case (MGMLIS3MDL::READ_TEMPERATURE): {
// std::memset(commandBuffer, 0, 3);
// commandBuffer[0] = readCommand(MGMLIS3MDL::TEMP_LOWBYTE, true);
rawPacket = commandBuffer;
rawPacketLen = 3;
return returnvalue::OK;
}
case (MGMLIS3MDL::IDENTIFY_DEVICE): {
return identifyDevice();
}
case (MGMLIS3MDL::TEMP_SENSOR_ENABLE): {
return enableTemperatureSensor(commandData, commandDataLen);
}
case (MGMLIS3MDL::SETUP_MGM): {
setupMgm();
return returnvalue::OK;
}
case (MGMLIS3MDL::ACCURACY_OP_MODE_SET): {
return setOperatingMode(commandData, commandDataLen);
}
default:
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
}
return returnvalue::FAILED;
}
// rawPacket = commandBuffer;
// rawPacketLen = 3;
// return returnvalue::OK;
// }
// case (MGMLIS3MDL::IDENTIFY_DEVICE): {
// return identifyDevice();
// }
// case (MGMLIS3MDL::TEMP_SENSOR_ENABLE): {
// return enableTemperatureSensor(commandData, commandDataLen);
// }
// case (MGMLIS3MDL::SETUP_MGM): {
// setupMgm();
// return returnvalue::OK;
// }
// case (MGMLIS3MDL::ACCURACY_OP_MODE_SET): {
// return setOperatingMode(commandData, commandDataLen);
// }
// default:
// return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
// }
// return returnvalue::FAILED;
// }
ReturnValue_t MgmLIS3MDLHandler::identifyDevice() {
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 doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
virtual uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
size_t commandDataLen) override;
// ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
// size_t commandDataLen) override;
ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
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 buildCommandFromCommand(*id, commandBuffer, commandLen);
return 0;//buildCommandFromCommand(*id, commandBuffer, commandLen);
}
ReturnValue_t MgmRM3100Handler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
const uint8_t *commandData,
size_t commandDataLen) {
switch (deviceCommand) {
case (RM3100::CONFIGURE_CMM): {
commandBuffer[0] = RM3100::CMM_REGISTER;
commandBuffer[1] = RM3100::CMM_VALUE;
rawPacket = commandBuffer;
rawPacketLen = 2;
break;
}
case (RM3100::READ_CMM): {
commandBuffer[0] = RM3100::CMM_REGISTER | RM3100::READ_MASK;
commandBuffer[1] = 0;
rawPacket = commandBuffer;
rawPacketLen = 2;
break;
}
case (RM3100::CONFIGURE_TMRC): {
return handleTmrcConfigCommand(deviceCommand, commandData, commandDataLen);
}
case (RM3100::READ_TMRC): {
commandBuffer[0] = RM3100::TMRC_REGISTER | RM3100::READ_MASK;
commandBuffer[1] = 0;
rawPacket = commandBuffer;
rawPacketLen = 2;
break;
}
case (RM3100::CONFIGURE_CYCLE_COUNT): {
return handleCycleCountConfigCommand(deviceCommand, commandData, commandDataLen);
}
case (RM3100::READ_CYCLE_COUNT): {
commandBuffer[0] = RM3100::CYCLE_COUNT_START_REGISTER | RM3100::READ_MASK;
std::memset(commandBuffer + 1, 0, 6);
rawPacket = commandBuffer;
rawPacketLen = 7;
break;
}
case (RM3100::READ_DATA): {
commandBuffer[0] = RM3100::MEASUREMENT_REG_START | RM3100::READ_MASK;
std::memset(commandBuffer + 1, 0, 9);
rawPacketLen = 10;
break;
}
default:
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
}
return returnvalue::OK;
}
// ReturnValue_t MgmRM3100Handler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
// const uint8_t *commandData,
// size_t commandDataLen) {
// switch (deviceCommand) {
// case (RM3100::CONFIGURE_CMM): {
// commandBuffer[0] = RM3100::CMM_REGISTER;
// commandBuffer[1] = RM3100::CMM_VALUE;
// rawPacket = commandBuffer;
// rawPacketLen = 2;
// break;
// }
// case (RM3100::READ_CMM): {
// commandBuffer[0] = RM3100::CMM_REGISTER | RM3100::READ_MASK;
// commandBuffer[1] = 0;
// rawPacket = commandBuffer;
// rawPacketLen = 2;
// break;
// }
// case (RM3100::CONFIGURE_TMRC): {
// return handleTmrcConfigCommand(deviceCommand, commandData, commandDataLen);
// }
// case (RM3100::READ_TMRC): {
// commandBuffer[0] = RM3100::TMRC_REGISTER | RM3100::READ_MASK;
// commandBuffer[1] = 0;
// rawPacket = commandBuffer;
// rawPacketLen = 2;
// break;
// }
// case (RM3100::CONFIGURE_CYCLE_COUNT): {
// return handleCycleCountConfigCommand(deviceCommand, commandData, commandDataLen);
// }
// case (RM3100::READ_CYCLE_COUNT): {
// commandBuffer[0] = RM3100::CYCLE_COUNT_START_REGISTER | RM3100::READ_MASK;
// std::memset(commandBuffer + 1, 0, 6);
// rawPacket = commandBuffer;
// rawPacketLen = 7;
// break;
// }
// case (RM3100::READ_DATA): {
// commandBuffer[0] = RM3100::MEASUREMENT_REG_START | RM3100::READ_MASK;
// std::memset(commandBuffer + 1, 0, 9);
// rawPacketLen = 10;
// break;
// }
// default:
// return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
// }
// return returnvalue::OK;
// }
ReturnValue_t MgmRM3100Handler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
*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,

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

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