From 511d07c0c78de7b1850e341dfcf8be7589f3c523 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Sun, 26 Feb 2023 21:26:24 +0100 Subject: [PATCH] refactored MGM device code --- .../devicehandlers/MgmLIS3MDLHandler.cpp | 190 +++++++----------- .../devicehandlers/MgmLIS3MDLHandler.h | 38 +--- .../devicehandlers/MgmRM3100Handler.cpp | 74 +++---- .../devicehandlers/MgmRM3100Handler.h | 21 +- .../devicedefinitions/CMakeLists.txt | 2 +- .../devicedefinitions/mgmLis3Helpers.cpp | 52 +++++ ...{MgmLIS3HandlerDefs.h => mgmLis3Helpers.h} | 34 +++- ...RM3100HandlerDefs.h => mgmRm3100Helpers.h} | 4 +- 8 files changed, 210 insertions(+), 205 deletions(-) create mode 100644 src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.cpp rename src/fsfw_hal/devicehandlers/devicedefinitions/{MgmLIS3HandlerDefs.h => mgmLis3Helpers.h} (86%) rename src/fsfw_hal/devicehandlers/devicedefinitions/{MgmRM3100HandlerDefs.h => mgmRm3100Helpers.h} (98%) diff --git a/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp b/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp index 82027bfd..a66745e1 100644 --- a/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp +++ b/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp @@ -10,11 +10,11 @@ MgmLIS3MDLHandler::MgmLIS3MDLHandler(object_id_t objectId, object_id_t deviceCom dataset(this), transitionDelay(transitionDelay) { // Set to default values right away - registers[0] = MGMLIS3MDL::CTRL_REG1_DEFAULT; - registers[1] = MGMLIS3MDL::CTRL_REG2_DEFAULT; - registers[2] = MGMLIS3MDL::CTRL_REG3_DEFAULT; - registers[3] = MGMLIS3MDL::CTRL_REG4_DEFAULT; - registers[4] = MGMLIS3MDL::CTRL_REG5_DEFAULT; + registers[0] = mgmLis3::CTRL_REG1_DEFAULT; + registers[1] = mgmLis3::CTRL_REG2_DEFAULT; + registers[2] = mgmLis3::CTRL_REG3_DEFAULT; + registers[3] = mgmLis3::CTRL_REG4_DEFAULT; + registers[4] = mgmLis3::CTRL_REG5_DEFAULT; } MgmLIS3MDLHandler::~MgmLIS3MDLHandler() {} @@ -63,15 +63,15 @@ ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(DeviceCommandId_t return DeviceHandlerBase::NOTHING_TO_SEND; } case (InternalState::STATE_FIRST_CONTACT): { - *id = MGMLIS3MDL::IDENTIFY_DEVICE; + *id = mgmLis3::IDENTIFY_DEVICE; break; } case (InternalState::STATE_SETUP): { - *id = MGMLIS3MDL::SETUP_MGM; + *id = mgmLis3::SETUP_MGM; break; } case (InternalState::STATE_CHECK_REGISTERS): { - *id = MGMLIS3MDL::READ_CONFIG_AND_DATA; + *id = mgmLis3::READ_CONFIG_AND_DATA; break; } default: { @@ -88,28 +88,12 @@ ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(DeviceCommandId_t return buildCommandFromCommand(*id, NULL, 0); } -uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) { - command |= (1 << MGMLIS3MDL::RW_BIT); - if (continuousCom == true) { - command |= (1 << MGMLIS3MDL::MS_BIT); - } - return command; -} - -uint8_t MgmLIS3MDLHandler::writeCommand(uint8_t command, bool continuousCom) { - command &= ~(1 << MGMLIS3MDL::RW_BIT); - if (continuousCom == true) { - command |= (1 << MGMLIS3MDL::MS_BIT); - } - return command; -} - void MgmLIS3MDLHandler::setupMgm() { - registers[0] = MGMLIS3MDL::CTRL_REG1_DEFAULT; - registers[1] = MGMLIS3MDL::CTRL_REG2_DEFAULT; - registers[2] = MGMLIS3MDL::CTRL_REG3_DEFAULT; - registers[3] = MGMLIS3MDL::CTRL_REG4_DEFAULT; - registers[4] = MGMLIS3MDL::CTRL_REG5_DEFAULT; + registers[0] = mgmLis3::CTRL_REG1_DEFAULT; + registers[1] = mgmLis3::CTRL_REG2_DEFAULT; + registers[2] = mgmLis3::CTRL_REG3_DEFAULT; + registers[3] = mgmLis3::CTRL_REG4_DEFAULT; + registers[4] = mgmLis3::CTRL_REG5_DEFAULT; prepareCtrlRegisterWrite(); } @@ -117,11 +101,11 @@ void MgmLIS3MDLHandler::setupMgm() { ReturnValue_t MgmLIS3MDLHandler::buildNormalDeviceCommand(DeviceCommandId_t *id) { // Data/config register will be read in an alternating manner. if (communicationStep == CommunicationStep::DATA) { - *id = MGMLIS3MDL::READ_CONFIG_AND_DATA; + *id = mgmLis3::READ_CONFIG_AND_DATA; communicationStep = CommunicationStep::TEMPERATURE; return buildCommandFromCommand(*id, NULL, 0); } else { - *id = MGMLIS3MDL::READ_TEMPERATURE; + *id = mgmLis3::READ_TEMPERATURE; communicationStep = CommunicationStep::DATA; return buildCommandFromCommand(*id, NULL, 0); } @@ -131,33 +115,33 @@ ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(DeviceCommandId_t devic const uint8_t *commandData, size_t commandDataLen) { switch (deviceCommand) { - case (MGMLIS3MDL::READ_CONFIG_AND_DATA): { + case (mgmLis3::READ_CONFIG_AND_DATA): { std::memset(commandBuffer, 0, sizeof(commandBuffer)); - commandBuffer[0] = readCommand(MGMLIS3MDL::CTRL_REG1, true); + commandBuffer[0] = mgmLis3::readCommand(mgmLis3::CTRL_REG1, true); rawPacket = commandBuffer; - rawPacketLen = MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1; + rawPacketLen = mgmLis3::NR_OF_DATA_AND_CFG_REGISTERS + 1; return returnvalue::OK; } - case (MGMLIS3MDL::READ_TEMPERATURE): { + case (mgmLis3::READ_TEMPERATURE): { std::memset(commandBuffer, 0, 3); - commandBuffer[0] = readCommand(MGMLIS3MDL::TEMP_LOWBYTE, true); + commandBuffer[0] = mgmLis3::readCommand(mgmLis3::TEMP_LOWBYTE, true); rawPacket = commandBuffer; rawPacketLen = 3; return returnvalue::OK; } - case (MGMLIS3MDL::IDENTIFY_DEVICE): { + case (mgmLis3::IDENTIFY_DEVICE): { return identifyDevice(); } - case (MGMLIS3MDL::TEMP_SENSOR_ENABLE): { + case (mgmLis3::TEMP_SENSOR_ENABLE): { return enableTemperatureSensor(commandData, commandDataLen); } - case (MGMLIS3MDL::SETUP_MGM): { + case (mgmLis3::SETUP_MGM): { setupMgm(); return returnvalue::OK; } - case (MGMLIS3MDL::ACCURACY_OP_MODE_SET): { + case (mgmLis3::ACCURACY_OP_MODE_SET): { return setOperatingMode(commandData, commandDataLen); } default: @@ -168,7 +152,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(DeviceCommandId_t devic ReturnValue_t MgmLIS3MDLHandler::identifyDevice() { uint32_t size = 2; - commandBuffer[0] = readCommand(MGMLIS3MDL::IDENTIFY_DEVICE_REG_ADDR); + commandBuffer[0] = mgmLis3::readCommand(mgmLis3::IDENTIFY_DEVICE_REG_ADDR); commandBuffer[1] = 0x00; rawPacket = commandBuffer; @@ -180,9 +164,9 @@ ReturnValue_t MgmLIS3MDLHandler::identifyDevice() { ReturnValue_t MgmLIS3MDLHandler::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId, size_t *foundLen) { *foundLen = len; - if (len == MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1) { + if (len == mgmLis3::NR_OF_DATA_AND_CFG_REGISTERS + 1) { *foundLen = len; - *foundId = MGMLIS3MDL::READ_CONFIG_AND_DATA; + *foundId = mgmLis3::READ_CONFIG_AND_DATA; // Check validity by checking config registers if (start[1] != registers[0] or start[2] != registers[1] or start[3] != registers[2] or start[4] != registers[3] or start[5] != registers[4]) { @@ -199,17 +183,17 @@ ReturnValue_t MgmLIS3MDLHandler::scanForReply(const uint8_t *start, size_t len, commandExecuted = true; } - } else if (len == MGMLIS3MDL::TEMPERATURE_REPLY_LEN) { + } else if (len == mgmLis3::TEMPERATURE_REPLY_LEN) { *foundLen = len; - *foundId = MGMLIS3MDL::READ_TEMPERATURE; - } else if (len == MGMLIS3MDL::SETUP_REPLY_LEN) { + *foundId = mgmLis3::READ_TEMPERATURE; + } else if (len == mgmLis3::SETUP_REPLY_LEN) { *foundLen = len; - *foundId = MGMLIS3MDL::SETUP_MGM; + *foundId = mgmLis3::SETUP_MGM; } else if (len == SINGLE_COMMAND_ANSWER_LEN) { *foundLen = len; *foundId = getPendingCommand(); - if (*foundId == MGMLIS3MDL::IDENTIFY_DEVICE) { - if (start[1] != MGMLIS3MDL::DEVICE_ID) { + if (*foundId == mgmLis3::IDENTIFY_DEVICE) { + if (start[1] != mgmLis3::DEVICE_ID) { #if FSFW_VERBOSE_LEVEL >= 1 #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "MGMHandlerLIS3MDL::scanForReply: " @@ -241,30 +225,31 @@ ReturnValue_t MgmLIS3MDLHandler::scanForReply(const uint8_t *start, size_t len, } ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) { switch (id) { - case MGMLIS3MDL::IDENTIFY_DEVICE: { + case mgmLis3::IDENTIFY_DEVICE: { break; } - case MGMLIS3MDL::SETUP_MGM: { + case mgmLis3::SETUP_MGM: { break; } - case MGMLIS3MDL::READ_CONFIG_AND_DATA: { + case mgmLis3::READ_CONFIG_AND_DATA: { + using namespace mgmLis3; // TODO: Store configuration in new local datasets. float sensitivityFactor = getSensitivityFactor(getSensitivity(registers[2])); int16_t mgmMeasurementRawX = - packet[MGMLIS3MDL::X_HIGHBYTE_IDX] << 8 | packet[MGMLIS3MDL::X_LOWBYTE_IDX]; + packet[mgmLis3::X_HIGHBYTE_IDX] << 8 | packet[mgmLis3::X_LOWBYTE_IDX]; int16_t mgmMeasurementRawY = - packet[MGMLIS3MDL::Y_HIGHBYTE_IDX] << 8 | packet[MGMLIS3MDL::Y_LOWBYTE_IDX]; + packet[mgmLis3::Y_HIGHBYTE_IDX] << 8 | packet[mgmLis3::Y_LOWBYTE_IDX]; int16_t mgmMeasurementRawZ = - packet[MGMLIS3MDL::Z_HIGHBYTE_IDX] << 8 | packet[MGMLIS3MDL::Z_LOWBYTE_IDX]; + packet[mgmLis3::Z_HIGHBYTE_IDX] << 8 | packet[mgmLis3::Z_LOWBYTE_IDX]; // Target value in microtesla float mgmX = static_cast(mgmMeasurementRawX) * sensitivityFactor * - MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR; + mgmLis3::GAUSS_TO_MICROTESLA_FACTOR; float mgmY = static_cast(mgmMeasurementRawY) * sensitivityFactor * - MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR; + mgmLis3::GAUSS_TO_MICROTESLA_FACTOR; float mgmZ = static_cast(mgmMeasurementRawZ) * sensitivityFactor * - MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR; + mgmLis3::GAUSS_TO_MICROTESLA_FACTOR; if (periodicPrintout) { if (debugDivider.checkAndIncrement()) { @@ -306,7 +291,7 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons break; } - case MGMLIS3MDL::READ_TEMPERATURE: { + case mgmLis3::READ_TEMPERATURE: { int16_t tempValueRaw = packet[2] << 8 | packet[1]; float tempValue = 25.0 + ((static_cast(tempValueRaw)) / 8.0); if (periodicPrintout) { @@ -334,41 +319,6 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons return returnvalue::OK; } -MGMLIS3MDL::Sensitivies MgmLIS3MDLHandler::getSensitivity(uint8_t ctrlRegister2) { - bool fs0Set = ctrlRegister2 & (1 << MGMLIS3MDL::FSO); // Checks if FS0 bit is set - bool fs1Set = ctrlRegister2 & (1 << MGMLIS3MDL::FS1); // Checks if FS1 bit is set - - if (fs0Set && fs1Set) - return MGMLIS3MDL::Sensitivies::GAUSS_16; - else if (!fs0Set && fs1Set) - return MGMLIS3MDL::Sensitivies::GAUSS_12; - else if (fs0Set && !fs1Set) - return MGMLIS3MDL::Sensitivies::GAUSS_8; - else - return MGMLIS3MDL::Sensitivies::GAUSS_4; -} - -float MgmLIS3MDLHandler::getSensitivityFactor(MGMLIS3MDL::Sensitivies sens) { - switch (sens) { - case (MGMLIS3MDL::GAUSS_4): { - return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_4_SENS; - } - case (MGMLIS3MDL::GAUSS_8): { - return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_8_SENS; - } - case (MGMLIS3MDL::GAUSS_12): { - return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_12_SENS; - } - case (MGMLIS3MDL::GAUSS_16): { - return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_16_SENS; - } - default: { - // Should never happen - return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_4_SENS; - } - } -} - ReturnValue_t MgmLIS3MDLHandler::enableTemperatureSensor(const uint8_t *commandData, size_t commandDataLen) { if (commandData == nullptr) { @@ -376,16 +326,16 @@ ReturnValue_t MgmLIS3MDLHandler::enableTemperatureSensor(const uint8_t *commandD } triggerEvent(CHANGE_OF_SETUP_PARAMETER); uint32_t size = 2; - commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1); + commandBuffer[0] = mgmLis3::writeCommand(mgmLis3::CTRL_REG1); if (commandDataLen > 1) { return INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS; } switch (commandData[0]) { - case (MGMLIS3MDL::ON): { + case (mgmLis3::ON): { commandBuffer[1] = registers[0] | (1 << 7); break; } - case (MGMLIS3MDL::OFF): { + case (mgmLis3::OFF): { commandBuffer[1] = registers[0] & ~(1 << 7); break; } @@ -408,23 +358,23 @@ ReturnValue_t MgmLIS3MDLHandler::setOperatingMode(const uint8_t *commandData, } switch (commandData[0]) { - case MGMLIS3MDL::LOW: - registers[0] = (registers[0] & (~(1 << MGMLIS3MDL::OM1))) & (~(1 << MGMLIS3MDL::OM0)); - registers[3] = (registers[3] & (~(1 << MGMLIS3MDL::OMZ1))) & (~(1 << MGMLIS3MDL::OMZ0)); + case mgmLis3::LOW: + registers[0] = (registers[0] & (~(1 << mgmLis3::OM1))) & (~(1 << mgmLis3::OM0)); + registers[3] = (registers[3] & (~(1 << mgmLis3::OMZ1))) & (~(1 << mgmLis3::OMZ0)); break; - case MGMLIS3MDL::MEDIUM: - registers[0] = (registers[0] & (~(1 << MGMLIS3MDL::OM1))) | (1 << MGMLIS3MDL::OM0); - registers[3] = (registers[3] & (~(1 << MGMLIS3MDL::OMZ1))) | (1 << MGMLIS3MDL::OMZ0); + case mgmLis3::MEDIUM: + registers[0] = (registers[0] & (~(1 << mgmLis3::OM1))) | (1 << mgmLis3::OM0); + registers[3] = (registers[3] & (~(1 << mgmLis3::OMZ1))) | (1 << mgmLis3::OMZ0); break; - case MGMLIS3MDL::HIGH: - registers[0] = (registers[0] | (1 << MGMLIS3MDL::OM1)) & (~(1 << MGMLIS3MDL::OM0)); - registers[3] = (registers[3] | (1 << MGMLIS3MDL::OMZ1)) & (~(1 << MGMLIS3MDL::OMZ0)); + case mgmLis3::HIGH: + registers[0] = (registers[0] | (1 << mgmLis3::OM1)) & (~(1 << mgmLis3::OM0)); + registers[3] = (registers[3] | (1 << mgmLis3::OMZ1)) & (~(1 << mgmLis3::OMZ0)); break; - case MGMLIS3MDL::ULTRA: - registers[0] = (registers[0] | (1 << MGMLIS3MDL::OM1)) | (1 << MGMLIS3MDL::OM0); - registers[3] = (registers[3] | (1 << MGMLIS3MDL::OMZ1)) | (1 << MGMLIS3MDL::OMZ0); + case mgmLis3::ULTRA: + registers[0] = (registers[0] | (1 << mgmLis3::OM1)) | (1 << mgmLis3::OM0); + registers[3] = (registers[3] | (1 << mgmLis3::OMZ1)) | (1 << mgmLis3::OMZ0); break; default: break; @@ -434,24 +384,24 @@ ReturnValue_t MgmLIS3MDLHandler::setOperatingMode(const uint8_t *commandData, } void MgmLIS3MDLHandler::fillCommandAndReplyMap() { - insertInCommandAndReplyMap(MGMLIS3MDL::READ_CONFIG_AND_DATA, 1, &dataset); - insertInCommandAndReplyMap(MGMLIS3MDL::READ_TEMPERATURE, 1); - insertInCommandAndReplyMap(MGMLIS3MDL::SETUP_MGM, 1); - insertInCommandAndReplyMap(MGMLIS3MDL::IDENTIFY_DEVICE, 1); - insertInCommandAndReplyMap(MGMLIS3MDL::TEMP_SENSOR_ENABLE, 1); - insertInCommandAndReplyMap(MGMLIS3MDL::ACCURACY_OP_MODE_SET, 1); + insertInCommandAndReplyMap(mgmLis3::READ_CONFIG_AND_DATA, 1, &dataset); + insertInCommandAndReplyMap(mgmLis3::READ_TEMPERATURE, 1); + insertInCommandAndReplyMap(mgmLis3::SETUP_MGM, 1); + insertInCommandAndReplyMap(mgmLis3::IDENTIFY_DEVICE, 1); + insertInCommandAndReplyMap(mgmLis3::TEMP_SENSOR_ENABLE, 1); + insertInCommandAndReplyMap(mgmLis3::ACCURACY_OP_MODE_SET, 1); } void MgmLIS3MDLHandler::setToGoToNormalMode(bool enable) { this->goToNormalMode = enable; } ReturnValue_t MgmLIS3MDLHandler::prepareCtrlRegisterWrite() { - commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1, true); + commandBuffer[0] = mgmLis3::writeCommand(mgmLis3::CTRL_REG1, true); - for (size_t i = 0; i < MGMLIS3MDL::NR_OF_CTRL_REGISTERS; i++) { + for (size_t i = 0; i < mgmLis3::NR_OF_CTRL_REGISTERS; i++) { commandBuffer[i + 1] = registers[i]; } rawPacket = commandBuffer; - rawPacketLen = MGMLIS3MDL::NR_OF_CTRL_REGISTERS + 1; + rawPacketLen = mgmLis3::NR_OF_CTRL_REGISTERS + 1; // We dont have to check if this is working because we just did i return returnvalue::OK; @@ -467,8 +417,8 @@ void MgmLIS3MDLHandler::modeChanged(void) { internalState = InternalState::STATE ReturnValue_t MgmLIS3MDLHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) { - localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTHS, &mgmXYZ); - localDataPoolMap.emplace(MGMLIS3MDL::TEMPERATURE_CELCIUS, &temperature); + localDataPoolMap.emplace(mgmLis3::FIELD_STRENGTHS, &mgmXYZ); + localDataPoolMap.emplace(mgmLis3::TEMPERATURE_CELCIUS, &temperature); poolManager.subscribeForRegularPeriodicPacket({dataset.getSid(), false, 10.0}); return returnvalue::OK; } diff --git a/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h b/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h index 3626a2b0..78b3b38c 100644 --- a/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h +++ b/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h @@ -1,7 +1,8 @@ #ifndef MISSION_DEVICES_MGMLIS3MDLHANDLER_H_ #define MISSION_DEVICES_MGMLIS3MDLHANDLER_H_ -#include "devicedefinitions/MgmLIS3HandlerDefs.h" +#include + #include "fsfw/devicehandlers/DeviceHandlerBase.h" #include "fsfw/globalfunctions/PeriodicOperationDivider.h" @@ -66,7 +67,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase { LocalDataPoolManager &poolManager) override; private: - MGMLIS3MDL::MgmPrimaryDataset dataset; + mgmLis3::MgmPrimaryDataset dataset; // Length a single command SPI answer static const uint8_t SINGLE_COMMAND_ANSWER_LEN = 2; @@ -74,7 +75,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase { // Single SPI command has 2 bytes, first for adress, second for content size_t singleComandSize = 2; // Has the size for all adresses of the lis3mdl + the continous write bit - uint8_t commandBuffer[MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1]; + uint8_t commandBuffer[mgmLis3::NR_OF_DATA_AND_CFG_REGISTERS + 1]; float absLimitX = 100; float absLimitY = 100; @@ -85,7 +86,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase { * registers when we want to change something. * --> everytime we change set a register we have to save it */ - uint8_t registers[MGMLIS3MDL::NR_OF_CTRL_REGISTERS]; + uint8_t registers[mgmLis3::NR_OF_CTRL_REGISTERS]; uint8_t statusRegister = 0; bool goToNormalMode = false; @@ -107,35 +108,6 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase { /*------------------------------------------------------------------------*/ /* Device specific commands and variables */ /*------------------------------------------------------------------------*/ - /** - * Sets the read bit for the command - * @param single command to set the read-bit at - * @param boolean to select a continuous read bit, default = false - */ - uint8_t readCommand(uint8_t command, bool continuousCom = false); - - /** - * Sets the write bit for the command - * @param single command to set the write-bit at - * @param boolean to select a continuous write bit, default = false - */ - uint8_t writeCommand(uint8_t command, bool continuousCom = false); - - /** - * This Method gets the full scale for the measurement range - * e.g.: +- 4 gauss. See p.25 datasheet. - * @return The ReturnValue does not contain the sign of the value - */ - MGMLIS3MDL::Sensitivies getSensitivity(uint8_t ctrlReg2); - - /** - * The 16 bit value needs to be multiplied with a sensitivity factor - * which depends on the sensitivity configuration - * - * @param sens Configured sensitivity of the LIS3 device - * @return Multiplication factor to get the sensor value from raw data. - */ - float getSensitivityFactor(MGMLIS3MDL::Sensitivies sens); /** * This Command detects the device ID diff --git a/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp b/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp index 4becd420..c17e3abc 100644 --- a/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp +++ b/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp @@ -63,21 +63,21 @@ ReturnValue_t MgmRM3100Handler::buildTransitionDeviceCommand(DeviceCommandId_t * return NOTHING_TO_SEND; } case (InternalState::CONFIGURE_CMM): { - *id = RM3100::CONFIGURE_CMM; + *id = mgmRm3100::CONFIGURE_CMM; break; } case (InternalState::READ_CMM): { - *id = RM3100::READ_CMM; + *id = mgmRm3100::READ_CMM; break; } case (InternalState::STATE_CONFIGURE_TMRC): { - commandBuffer[0] = RM3100::TMRC_DEFAULT_VALUE; + commandBuffer[0] = mgmRm3100::TMRC_DEFAULT_VALUE; commandLen = 1; - *id = RM3100::CONFIGURE_TMRC; + *id = mgmRm3100::CONFIGURE_TMRC; break; } case (InternalState::STATE_READ_TMRC): { - *id = RM3100::READ_TMRC; + *id = mgmRm3100::READ_TMRC; break; } default: @@ -103,42 +103,42 @@ ReturnValue_t MgmRM3100Handler::buildCommandFromCommand(DeviceCommandId_t device const uint8_t *commandData, size_t commandDataLen) { switch (deviceCommand) { - case (RM3100::CONFIGURE_CMM): { - commandBuffer[0] = RM3100::CMM_REGISTER; - commandBuffer[1] = RM3100::CMM_VALUE; + case (mgmRm3100::CONFIGURE_CMM): { + commandBuffer[0] = mgmRm3100::CMM_REGISTER; + commandBuffer[1] = mgmRm3100::CMM_VALUE; rawPacket = commandBuffer; rawPacketLen = 2; break; } - case (RM3100::READ_CMM): { - commandBuffer[0] = RM3100::CMM_REGISTER | RM3100::READ_MASK; + case (mgmRm3100::READ_CMM): { + commandBuffer[0] = mgmRm3100::CMM_REGISTER | mgmRm3100::READ_MASK; commandBuffer[1] = 0; rawPacket = commandBuffer; rawPacketLen = 2; break; } - case (RM3100::CONFIGURE_TMRC): { + case (mgmRm3100::CONFIGURE_TMRC): { return handleTmrcConfigCommand(deviceCommand, commandData, commandDataLen); } - case (RM3100::READ_TMRC): { - commandBuffer[0] = RM3100::TMRC_REGISTER | RM3100::READ_MASK; + case (mgmRm3100::READ_TMRC): { + commandBuffer[0] = mgmRm3100::TMRC_REGISTER | mgmRm3100::READ_MASK; commandBuffer[1] = 0; rawPacket = commandBuffer; rawPacketLen = 2; break; } - case (RM3100::CONFIGURE_CYCLE_COUNT): { + case (mgmRm3100::CONFIGURE_CYCLE_COUNT): { return handleCycleCountConfigCommand(deviceCommand, commandData, commandDataLen); } - case (RM3100::READ_CYCLE_COUNT): { - commandBuffer[0] = RM3100::CYCLE_COUNT_START_REGISTER | RM3100::READ_MASK; + case (mgmRm3100::READ_CYCLE_COUNT): { + commandBuffer[0] = mgmRm3100::CYCLE_COUNT_START_REGISTER | mgmRm3100::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; + case (mgmRm3100::READ_DATA): { + commandBuffer[0] = mgmRm3100::MEASUREMENT_REG_START | mgmRm3100::READ_MASK; std::memset(commandBuffer + 1, 0, 9); rawPacketLen = 10; break; @@ -150,7 +150,7 @@ ReturnValue_t MgmRM3100Handler::buildCommandFromCommand(DeviceCommandId_t device } ReturnValue_t MgmRM3100Handler::buildNormalDeviceCommand(DeviceCommandId_t *id) { - *id = RM3100::READ_DATA; + *id = mgmRm3100::READ_DATA; return buildCommandFromCommand(*id, nullptr, 0); } @@ -165,16 +165,16 @@ ReturnValue_t MgmRM3100Handler::scanForReply(const uint8_t *start, size_t len, ReturnValue_t MgmRM3100Handler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) { ReturnValue_t result = returnvalue::OK; switch (id) { - case (RM3100::CONFIGURE_CMM): - case (RM3100::CONFIGURE_CYCLE_COUNT): - case (RM3100::CONFIGURE_TMRC): { + case (mgmRm3100::CONFIGURE_CMM): + case (mgmRm3100::CONFIGURE_CYCLE_COUNT): + case (mgmRm3100::CONFIGURE_TMRC): { // We can only check whether write was successful with read operation if (getMode() == _MODE_START_UP) { commandExecuted = true; } break; } - case (RM3100::READ_CMM): { + case (mgmRm3100::READ_CMM): { uint8_t cmmValue = packet[1]; // We clear the seventh bit in any case // because this one is zero sometimes for some reason @@ -188,7 +188,7 @@ ReturnValue_t MgmRM3100Handler::interpretDeviceReply(DeviceCommandId_t id, const } break; } - case (RM3100::READ_TMRC): { + case (mgmRm3100::READ_TMRC): { if (packet[1] == tmrcRegValue) { commandExecuted = true; // Reading TMRC was commanded. Trigger event to inform ground @@ -202,7 +202,7 @@ ReturnValue_t MgmRM3100Handler::interpretDeviceReply(DeviceCommandId_t id, const } break; } - case (RM3100::READ_CYCLE_COUNT): { + case (mgmRm3100::READ_CYCLE_COUNT): { uint16_t cycleCountX = packet[1] << 8 | packet[2]; uint16_t cycleCountY = packet[3] << 8 | packet[4]; uint16_t cycleCountZ = packet[5] << 8 | packet[6]; @@ -217,7 +217,7 @@ ReturnValue_t MgmRM3100Handler::interpretDeviceReply(DeviceCommandId_t id, const } break; } - case (RM3100::READ_DATA): { + case (mgmRm3100::READ_DATA): { result = handleDataReadout(packet); break; } @@ -244,7 +244,7 @@ ReturnValue_t MgmRM3100Handler::handleCycleCountConfigCommand(DeviceCommandId_t return DeviceHandlerIF::INVALID_COMMAND_PARAMETER; } - commandBuffer[0] = RM3100::CYCLE_COUNT_VALUE; + commandBuffer[0] = mgmRm3100::CYCLE_COUNT_VALUE; std::memcpy(commandBuffer + 1, &cycleCountRegValueX, 2); std::memcpy(commandBuffer + 3, &cycleCountRegValueY, 2); std::memcpy(commandBuffer + 5, &cycleCountRegValueZ, 2); @@ -255,7 +255,7 @@ ReturnValue_t MgmRM3100Handler::handleCycleCountConfigCommand(DeviceCommandId_t ReturnValue_t MgmRM3100Handler::handleCycleCommand(bool oneCycleValue, const uint8_t *commandData, size_t commandDataLen) { - RM3100::CycleCountCommand command(oneCycleValue); + mgmRm3100::CycleCountCommand command(oneCycleValue); ReturnValue_t result = command.deSerialize(&commandData, &commandDataLen, SerializeIF::Endianness::BIG); if (result != returnvalue::OK) { @@ -284,7 +284,7 @@ ReturnValue_t MgmRM3100Handler::handleTmrcConfigCommand(DeviceCommandId_t device return DeviceHandlerIF::INVALID_COMMAND_PARAMETER; } - commandBuffer[0] = RM3100::TMRC_REGISTER; + commandBuffer[0] = mgmRm3100::TMRC_REGISTER; commandBuffer[1] = commandData[0]; tmrcRegValue = commandData[0]; rawPacketLen = 2; @@ -293,23 +293,23 @@ ReturnValue_t MgmRM3100Handler::handleTmrcConfigCommand(DeviceCommandId_t device } void MgmRM3100Handler::fillCommandAndReplyMap() { - insertInCommandAndReplyMap(RM3100::CONFIGURE_CMM, 3); - insertInCommandAndReplyMap(RM3100::READ_CMM, 3); + insertInCommandAndReplyMap(mgmRm3100::CONFIGURE_CMM, 3); + insertInCommandAndReplyMap(mgmRm3100::READ_CMM, 3); - insertInCommandAndReplyMap(RM3100::CONFIGURE_TMRC, 3); - insertInCommandAndReplyMap(RM3100::READ_TMRC, 3); + insertInCommandAndReplyMap(mgmRm3100::CONFIGURE_TMRC, 3); + insertInCommandAndReplyMap(mgmRm3100::READ_TMRC, 3); - insertInCommandAndReplyMap(RM3100::CONFIGURE_CYCLE_COUNT, 3); - insertInCommandAndReplyMap(RM3100::READ_CYCLE_COUNT, 3); + insertInCommandAndReplyMap(mgmRm3100::CONFIGURE_CYCLE_COUNT, 3); + insertInCommandAndReplyMap(mgmRm3100::READ_CYCLE_COUNT, 3); - insertInCommandAndReplyMap(RM3100::READ_DATA, 3, &primaryDataset); + insertInCommandAndReplyMap(mgmRm3100::READ_DATA, 3, &primaryDataset); } void MgmRM3100Handler::modeChanged() { internalState = InternalState::NONE; } ReturnValue_t MgmRM3100Handler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) { - localDataPoolMap.emplace(RM3100::FIELD_STRENGTHS, &mgmXYZ); + localDataPoolMap.emplace(mgmRm3100::FIELD_STRENGTHS, &mgmXYZ); poolManager.subscribeForRegularPeriodicPacket({primaryDataset.getSid(), false, 10.0}); return returnvalue::OK; } diff --git a/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h b/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h index d45b2404..1e56bc9d 100644 --- a/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h +++ b/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h @@ -1,7 +1,8 @@ #ifndef MISSION_DEVICES_MGMRM3100HANDLER_H_ #define MISSION_DEVICES_MGMRM3100HANDLER_H_ -#include "devicedefinitions/MgmRM3100HandlerDefs.h" +#include + #include "fsfw/devicehandlers/DeviceHandlerBase.h" #include "fsfw/globalfunctions/PeriodicOperationDivider.h" @@ -69,19 +70,19 @@ class MgmRM3100Handler : public DeviceHandlerBase { }; InternalState internalState = InternalState::NONE; bool commandExecuted = false; - RM3100::Rm3100PrimaryDataset primaryDataset; + mgmRm3100::Rm3100PrimaryDataset primaryDataset; uint8_t commandBuffer[10]; uint8_t commandBufferLen = 0; - uint8_t cmmRegValue = RM3100::CMM_VALUE; - uint8_t tmrcRegValue = RM3100::TMRC_DEFAULT_VALUE; - uint16_t cycleCountRegValueX = RM3100::CYCLE_COUNT_VALUE; - uint16_t cycleCountRegValueY = RM3100::CYCLE_COUNT_VALUE; - uint16_t cycleCountRegValueZ = RM3100::CYCLE_COUNT_VALUE; - float scaleFactorX = 1.0 / RM3100::DEFAULT_GAIN; - float scaleFactorY = 1.0 / RM3100::DEFAULT_GAIN; - float scaleFactorZ = 1.0 / RM3100::DEFAULT_GAIN; + uint8_t cmmRegValue = mgmRm3100::CMM_VALUE; + uint8_t tmrcRegValue = mgmRm3100::TMRC_DEFAULT_VALUE; + uint16_t cycleCountRegValueX = mgmRm3100::CYCLE_COUNT_VALUE; + uint16_t cycleCountRegValueY = mgmRm3100::CYCLE_COUNT_VALUE; + uint16_t cycleCountRegValueZ = mgmRm3100::CYCLE_COUNT_VALUE; + float scaleFactorX = 1.0 / mgmRm3100::DEFAULT_GAIN; + float scaleFactorY = 1.0 / mgmRm3100::DEFAULT_GAIN; + float scaleFactorZ = 1.0 / mgmRm3100::DEFAULT_GAIN; bool goToNormalModeAtStartup = false; uint32_t transitionDelay; diff --git a/src/fsfw_hal/devicehandlers/devicedefinitions/CMakeLists.txt b/src/fsfw_hal/devicehandlers/devicedefinitions/CMakeLists.txt index e77862c1..2d874fb5 100644 --- a/src/fsfw_hal/devicehandlers/devicedefinitions/CMakeLists.txt +++ b/src/fsfw_hal/devicehandlers/devicedefinitions/CMakeLists.txt @@ -1 +1 @@ -target_sources(${LIB_FSFW_NAME} PRIVATE gyroL3gHelpers.cpp) +target_sources(${LIB_FSFW_NAME} PRIVATE gyroL3gHelpers.cpp mgmLis3Helpers.cpp) diff --git a/src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.cpp b/src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.cpp new file mode 100644 index 00000000..3609ea01 --- /dev/null +++ b/src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.cpp @@ -0,0 +1,52 @@ +#include "mgmLis3Helpers.h" + +uint8_t mgmLis3::readCommand(uint8_t command, bool continuousCom) { + command |= (1 << mgmLis3::RW_BIT); + if (continuousCom == true) { + command |= (1 << mgmLis3::MS_BIT); + } + return command; +} + +uint8_t mgmLis3::writeCommand(uint8_t command, bool continuousCom) { + command &= ~(1 << mgmLis3::RW_BIT); + if (continuousCom == true) { + command |= (1 << mgmLis3::MS_BIT); + } + return command; +} + +mgmLis3::Sensitivies mgmLis3::getSensitivity(uint8_t ctrlRegister2) { + bool fs0Set = ctrlRegister2 & (1 << mgmLis3::FSO); // Checks if FS0 bit is set + bool fs1Set = ctrlRegister2 & (1 << mgmLis3::FS1); // Checks if FS1 bit is set + + if (fs0Set && fs1Set) + return mgmLis3::Sensitivies::GAUSS_16; + else if (!fs0Set && fs1Set) + return mgmLis3::Sensitivies::GAUSS_12; + else if (fs0Set && !fs1Set) + return mgmLis3::Sensitivies::GAUSS_8; + else + return mgmLis3::Sensitivies::GAUSS_4; +} + +float mgmLis3::getSensitivityFactor(mgmLis3::Sensitivies sens) { + switch (sens) { + case (mgmLis3::GAUSS_4): { + return mgmLis3::FIELD_LSB_PER_GAUSS_4_SENS; + } + case (mgmLis3::GAUSS_8): { + return mgmLis3::FIELD_LSB_PER_GAUSS_8_SENS; + } + case (mgmLis3::GAUSS_12): { + return mgmLis3::FIELD_LSB_PER_GAUSS_12_SENS; + } + case (mgmLis3::GAUSS_16): { + return mgmLis3::FIELD_LSB_PER_GAUSS_16_SENS; + } + default: { + // Should never happen + return mgmLis3::FIELD_LSB_PER_GAUSS_4_SENS; + } + } +} diff --git a/src/fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h b/src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h similarity index 86% rename from src/fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h rename to src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h index 34237637..8d47a200 100644 --- a/src/fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h +++ b/src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h @@ -7,13 +7,43 @@ #include -namespace MGMLIS3MDL { +namespace mgmLis3 { enum Set { ON, OFF }; enum OpMode { LOW, MEDIUM, HIGH, ULTRA }; enum Sensitivies : uint8_t { GAUSS_4 = 4, GAUSS_8 = 8, GAUSS_12 = 12, GAUSS_16 = 16 }; +/** + * Sets the read bit for the command + * @param single command to set the read-bit at + * @param boolean to select a continuous read bit, default = false + */ +uint8_t readCommand(uint8_t command, bool continuousCom = false); + +/** + * Sets the write bit for the command + * @param single command to set the write-bit at + * @param boolean to select a continuous write bit, default = false + */ +uint8_t writeCommand(uint8_t command, bool continuousCom = false); + +/** + * This Method gets the full scale for the measurement range + * e.g.: +- 4 gauss. See p.25 datasheet. + * @return The ReturnValue does not contain the sign of the value + */ +mgmLis3::Sensitivies getSensitivity(uint8_t ctrlReg2); + +/** + * The 16 bit value needs to be multiplied with a sensitivity factor + * which depends on the sensitivity configuration + * + * @param sens Configured sensitivity of the LIS3 device + * @return Multiplication factor to get the sensor value from raw data. + */ +float getSensitivityFactor(mgmLis3::Sensitivies sens); + /* Actually 15, we just round up a bit */ static constexpr size_t MAX_BUFFER_SIZE = 16; @@ -154,6 +184,6 @@ class MgmPrimaryDataset : public StaticLocalDataSet<4> { lp_var_t temperature = lp_var_t(sid.objectId, TEMPERATURE_CELCIUS, this); }; -} // namespace MGMLIS3MDL +} // namespace mgmLis3 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_MGMLIS3HANDLERDEFS_H_ */ diff --git a/src/fsfw_hal/devicehandlers/devicedefinitions/MgmRM3100HandlerDefs.h b/src/fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h similarity index 98% rename from src/fsfw_hal/devicehandlers/devicedefinitions/MgmRM3100HandlerDefs.h rename to src/fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h index a2aa8ab0..680bd13d 100644 --- a/src/fsfw_hal/devicehandlers/devicedefinitions/MgmRM3100HandlerDefs.h +++ b/src/fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h @@ -8,7 +8,7 @@ #include -namespace RM3100 { +namespace mgmRm3100 { /* Actually 10, we round up a little bit */ static constexpr size_t MAX_BUFFER_SIZE = 12; @@ -115,6 +115,6 @@ class Rm3100PrimaryDataset : public StaticLocalDataSet<3> { lp_vec_t fieldStrengths = lp_vec_t(sid.objectId, FIELD_STRENGTHS, this); }; -} // namespace RM3100 +} // namespace mgmRm3100 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERRM3100DEFINITIONS_H_ */