refactored MGM device code

update for SPI/gyro dev handler code
2023-02-26 21:26:24 +01:00 · 2023-02-26 14:54:35 +01:00
14 changed files with 290 additions and 267 deletions
--- a/src/fsfw_hal/devicehandlers/CMakeLists.txt
+++ b/src/fsfw_hal/devicehandlers/CMakeLists.txt
@@ -1,3 +1,5 @@
 target_sources(
  ${LIB_FSFW_NAME} PRIVATE GyroL3GD20Handler.cpp MgmRM3100Handler.cpp
                           MgmLIS3MDLHandler.cpp)
+
+add_subdirectory(devicedefinitions)
--- a/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp
+++ b/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp
@@ -46,17 +46,17 @@ ReturnValue_t GyroHandlerL3GD20H::buildTransitionDeviceCommand(DeviceCommandId_t
      return NOTHING_TO_SEND;
    }
    case (InternalState::CONFIGURE): {
-      *id = L3GD20H::CONFIGURE_CTRL_REGS;
+      *id = l3gd20h::CONFIGURE_CTRL_REGS;
      uint8_t command[5];
-      command[0] = L3GD20H::CTRL_REG_1_VAL;
-      command[1] = L3GD20H::CTRL_REG_2_VAL;
-      command[2] = L3GD20H::CTRL_REG_3_VAL;
-      command[3] = L3GD20H::CTRL_REG_4_VAL;
-      command[4] = L3GD20H::CTRL_REG_5_VAL;
+      command[0] = l3gd20h::CTRL_REG_1_VAL;
+      command[1] = l3gd20h::CTRL_REG_2_VAL;
+      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);
    }
    case (InternalState::CHECK_REGS): {
-      *id = L3GD20H::READ_REGS;
+      *id = l3gd20h::READ_REGS;
      return buildCommandFromCommand(*id, nullptr, 0);
    }
    default:
@@ -76,7 +76,7 @@ ReturnValue_t GyroHandlerL3GD20H::buildTransitionDeviceCommand(DeviceCommandId_t
 }

 ReturnValue_t GyroHandlerL3GD20H::buildNormalDeviceCommand(DeviceCommandId_t *id) {
-  *id = L3GD20H::READ_REGS;
+  *id = l3gd20h::READ_REGS;
  return buildCommandFromCommand(*id, nullptr, 0);
 }

@@ -84,15 +84,15 @@ ReturnValue_t GyroHandlerL3GD20H::buildCommandFromCommand(DeviceCommandId_t devi
                                                          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);
+    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;
+      rawPacketLen = l3gd20h::READ_LEN + 1;
      break;
    }
-    case (L3GD20H::CONFIGURE_CTRL_REGS): {
-      commandBuffer[0] = L3GD20H::CTRL_REG_1 | L3GD20H::AUTO_INCREMENT_MASK;
+    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;
      }
@@ -103,15 +103,15 @@ ReturnValue_t GyroHandlerL3GD20H::buildCommandFromCommand(DeviceCommandId_t devi
      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;
+        sensitivity = l3gd20h::SENSITIVITY_00;
      } else if (not fsH and fsL) {
-        sensitivity = L3GD20H::SENSITIVITY_01;
+        sensitivity = l3gd20h::SENSITIVITY_01;
      } else {
-        sensitivity = L3GD20H::SENSITIVITY_11;
+        sensitivity = l3gd20h::SENSITIVITY_11;
      }

      commandBuffer[1] = ctrlReg1Value;
@@ -124,8 +124,8 @@ ReturnValue_t GyroHandlerL3GD20H::buildCommandFromCommand(DeviceCommandId_t devi
      rawPacketLen = 6;
      break;
    }
-    case (L3GD20H::READ_CTRL_REGS): {
-      commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK | L3GD20H::READ_MASK;
+    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;
@@ -151,11 +151,11 @@ ReturnValue_t GyroHandlerL3GD20H::interpretDeviceReply(DeviceCommandId_t id,
                                                       const uint8_t *packet) {
  ReturnValue_t result = returnvalue::OK;
  switch (id) {
-    case (L3GD20H::CONFIGURE_CTRL_REGS): {
+    case (l3gd20h::CONFIGURE_CTRL_REGS): {
      commandExecuted = true;
      break;
    }
-    case (L3GD20H::READ_CTRL_REGS): {
+    case (l3gd20h::READ_CTRL_REGS): {
      if (packet[1] == ctrlReg1Value and packet[2] == ctrlReg2Value and
          packet[3] == ctrlReg3Value and packet[4] == ctrlReg4Value and
          packet[5] == ctrlReg5Value) {
@@ -167,7 +167,7 @@ ReturnValue_t GyroHandlerL3GD20H::interpretDeviceReply(DeviceCommandId_t id,
      }
      break;
    }
-    case (L3GD20H::READ_REGS): {
+    case (l3gd20h::READ_REGS): {
      if (packet[1] != ctrlReg1Value and packet[2] != ctrlReg2Value and
          packet[3] != ctrlReg3Value and packet[4] != ctrlReg4Value and
          packet[5] != ctrlReg5Value) {
@@ -178,16 +178,16 @@ ReturnValue_t GyroHandlerL3GD20H::interpretDeviceReply(DeviceCommandId_t id,
        }
      }

-      statusReg = packet[L3GD20H::STATUS_IDX];
+      statusReg = packet[l3gd20h::STATUS_IDX];

-      int16_t angVelocXRaw = packet[L3GD20H::OUT_X_H] << 8 | packet[L3GD20H::OUT_X_L];
-      int16_t angVelocYRaw = packet[L3GD20H::OUT_Y_H] << 8 | packet[L3GD20H::OUT_Y_L];
-      int16_t angVelocZRaw = packet[L3GD20H::OUT_Z_H] << 8 | packet[L3GD20H::OUT_Z_L];
+      int16_t angVelocXRaw = packet[l3gd20h::OUT_X_H] << 8 | packet[l3gd20h::OUT_X_L];
+      int16_t angVelocYRaw = packet[l3gd20h::OUT_Y_H] << 8 | packet[l3gd20h::OUT_Y_L];
+      int16_t angVelocZRaw = packet[l3gd20h::OUT_Z_H] << 8 | packet[l3gd20h::OUT_Z_L];
      float angVelocX = angVelocXRaw * sensitivity;
      float angVelocY = angVelocYRaw * sensitivity;
      float angVelocZ = angVelocZRaw * sensitivity;

-      int8_t temperaturOffset = (-1) * packet[L3GD20H::TEMPERATURE_IDX];
+      int8_t temperaturOffset = (-1) * packet[l3gd20h::TEMPERATURE_IDX];
      float temperature = 25.0 + temperaturOffset;
      if (periodicPrintout) {
        if (debugDivider.checkAndIncrement()) {
@@ -248,19 +248,19 @@ void GyroHandlerL3GD20H::setToGoToNormalMode(bool enable) { this->goNormalModeIm

 ReturnValue_t GyroHandlerL3GD20H::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                          LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_X, new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Y, new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Z, new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(L3GD20H::TEMPERATURE, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(l3gd20h::ANG_VELOC_X, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(l3gd20h::ANG_VELOC_Y, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(l3gd20h::ANG_VELOC_Z, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(l3gd20h::TEMPERATURE, new PoolEntry<float>({0.0}));
  poolManager.subscribeForRegularPeriodicPacket(
      subdp::RegularHkPeriodicParams(dataset.getSid(), false, 10.0));
  return returnvalue::OK;
 }

 void GyroHandlerL3GD20H::fillCommandAndReplyMap() {
-  insertInCommandAndReplyMap(L3GD20H::READ_REGS, 1, &dataset);
-  insertInCommandAndReplyMap(L3GD20H::CONFIGURE_CTRL_REGS, 1);
-  insertInCommandAndReplyMap(L3GD20H::READ_CTRL_REGS, 1);
+  insertInCommandAndReplyMap(l3gd20h::READ_REGS, 1, &dataset);
+  insertInCommandAndReplyMap(l3gd20h::CONFIGURE_CTRL_REGS, 1);
+  insertInCommandAndReplyMap(l3gd20h::READ_CTRL_REGS, 1);
 }

 void GyroHandlerL3GD20H::modeChanged() { internalState = InternalState::NONE; }
--- a/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.h
+++ b/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.h
@@ -3,8 +3,7 @@

 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <fsfw/globalfunctions/PeriodicOperationDivider.h>
-
-#include "devicedefinitions/GyroL3GD20Definitions.h"
+#include <fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h>

 /**
 * @brief 	Device Handler for the L3GD20H gyroscope sensor
@@ -59,9 +58,9 @@ class GyroHandlerL3GD20H : public DeviceHandlerBase {
  uint32_t transitionDelayMs = 0;
  GyroPrimaryDataset dataset;

-  float absLimitX = L3GD20H::RANGE_DPS_00;
-  float absLimitY = L3GD20H::RANGE_DPS_00;
-  float absLimitZ = L3GD20H::RANGE_DPS_00;
+  float absLimitX = l3gd20h::RANGE_DPS_00;
+  float absLimitY = l3gd20h::RANGE_DPS_00;
+  float absLimitZ = l3gd20h::RANGE_DPS_00;

  enum class InternalState { NONE, CONFIGURE, CHECK_REGS, NORMAL };
  InternalState internalState = InternalState::NONE;
@@ -70,16 +69,16 @@ class GyroHandlerL3GD20H : public DeviceHandlerBase {
  uint8_t statusReg = 0;
  bool goNormalModeImmediately = false;

-  uint8_t ctrlReg1Value = L3GD20H::CTRL_REG_1_VAL;
-  uint8_t ctrlReg2Value = L3GD20H::CTRL_REG_2_VAL;
-  uint8_t ctrlReg3Value = L3GD20H::CTRL_REG_3_VAL;
-  uint8_t ctrlReg4Value = L3GD20H::CTRL_REG_4_VAL;
-  uint8_t ctrlReg5Value = L3GD20H::CTRL_REG_5_VAL;
+  uint8_t ctrlReg1Value = l3gd20h::CTRL_REG_1_VAL;
+  uint8_t ctrlReg2Value = l3gd20h::CTRL_REG_2_VAL;
+  uint8_t ctrlReg3Value = l3gd20h::CTRL_REG_3_VAL;
+  uint8_t ctrlReg4Value = l3gd20h::CTRL_REG_4_VAL;
+  uint8_t ctrlReg5Value = l3gd20h::CTRL_REG_5_VAL;

-  uint8_t commandBuffer[L3GD20H::READ_LEN + 1];
+  uint8_t commandBuffer[l3gd20h::READ_LEN + 1];

  // Set default value
-  float sensitivity = L3GD20H::SENSITIVITY_00;
+  float sensitivity = l3gd20h::SENSITIVITY_00;

  bool periodicPrintout = false;
  PeriodicOperationDivider debugDivider = PeriodicOperationDivider(3);
--- 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<float>(mgmMeasurementRawX) * sensitivityFactor *
-                   MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR;
+                   mgmLis3::GAUSS_TO_MICROTESLA_FACTOR;
      float mgmY = static_cast<float>(mgmMeasurementRawY) * sensitivityFactor *
-                   MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR;
+                   mgmLis3::GAUSS_TO_MICROTESLA_FACTOR;
      float mgmZ = static_cast<float>(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<float>(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;
 }
--- 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 <fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h>
+
 #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
--- 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;
 }
--- 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 <fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h>
+
 #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;
--- a/src/fsfw_hal/devicehandlers/devicedefinitions/CMakeLists.txt
+++ b/src/fsfw_hal/devicehandlers/devicedefinitions/CMakeLists.txt
@@ -0,0 +1 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE gyroL3gHelpers.cpp mgmLis3Helpers.cpp)
--- a/src/fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.cpp
+++ b/src/fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.cpp
@@ -0,0 +1,14 @@
+#include <fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h>
+
+float l3gd20h::ctrlReg4ToSensitivity(uint8_t reg) {
+  bool fsH = reg & l3gd20h::SET_FS_1;
+  bool fsL = reg & l3gd20h::SET_FS_0;
+
+  if (not fsH and not fsL) {
+    return l3gd20h::SENSITIVITY_00;
+  } else if (not fsH and fsL) {
+    return l3gd20h::SENSITIVITY_01;
+  } else {
+    return l3gd20h::SENSITIVITY_11;
+  }
+}
--- a/src/fsfw_hal/devicehandlers/devicedefinitions/GyroL3GD20Definitions.h
+++ b/src/fsfw_hal/devicehandlers/devicedefinitions/GyroL3GD20Definitions.h
@@ -6,7 +6,9 @@

 #include <cstdint>

-namespace L3GD20H {
+namespace l3gd20h {
+
+float ctrlReg4ToSensitivity(uint8_t reg);

 /* Actual size is 15 but we round up a bit */
 static constexpr size_t MAX_BUFFER_SIZE = 16;
@@ -103,31 +105,33 @@ static constexpr DeviceCommandId_t READ_REGS = 0;
 static constexpr DeviceCommandId_t CONFIGURE_CTRL_REGS = 1;
 static constexpr DeviceCommandId_t READ_CTRL_REGS = 2;

+static constexpr DeviceCommandId_t REQUEST = 0x70;
+static constexpr DeviceCommandId_t REPLY = 0x77;
+
 static constexpr uint32_t GYRO_DATASET_ID = READ_REGS;

 enum GyroPoolIds : lp_id_t { ANG_VELOC_X, ANG_VELOC_Y, ANG_VELOC_Z, TEMPERATURE };

-}  // namespace L3GD20H
+}  // namespace l3gd20h

 class GyroPrimaryDataset : public StaticLocalDataSet<5> {
 public:
  /** Constructor  for data users like controllers */
  GyroPrimaryDataset(object_id_t mgmId)
-      : StaticLocalDataSet(sid_t(mgmId, L3GD20H::GYRO_DATASET_ID)) {
+      : StaticLocalDataSet(sid_t(mgmId, l3gd20h::GYRO_DATASET_ID)) {
    setAllVariablesReadOnly();
  }
-
-  /* Angular velocities in degrees per second (DPS) */
-  lp_var_t<float> angVelocX = lp_var_t<float>(sid.objectId, L3GD20H::ANG_VELOC_X, this);
-  lp_var_t<float> angVelocY = lp_var_t<float>(sid.objectId, L3GD20H::ANG_VELOC_Y, this);
-  lp_var_t<float> angVelocZ = lp_var_t<float>(sid.objectId, L3GD20H::ANG_VELOC_Z, this);
-  lp_var_t<float> temperature = lp_var_t<float>(sid.objectId, L3GD20H::TEMPERATURE, this);
-
- private:
-  friend class GyroHandlerL3GD20H;
  /** Constructor  for the data creator */
  GyroPrimaryDataset(HasLocalDataPoolIF* hkOwner)
-      : StaticLocalDataSet(hkOwner, L3GD20H::GYRO_DATASET_ID) {}
+      : StaticLocalDataSet(hkOwner, l3gd20h::GYRO_DATASET_ID) {}
+
+  /* Angular velocities in degrees per second (DPS) */
+  lp_var_t<float> angVelocX = lp_var_t<float>(sid.objectId, l3gd20h::ANG_VELOC_X, this);
+  lp_var_t<float> angVelocY = lp_var_t<float>(sid.objectId, l3gd20h::ANG_VELOC_Y, this);
+  lp_var_t<float> angVelocZ = lp_var_t<float>(sid.objectId, l3gd20h::ANG_VELOC_Z, this);
+  lp_var_t<float> temperature = lp_var_t<float>(sid.objectId, l3gd20h::TEMPERATURE, this);
+
+ private:
 };

 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_GYROL3GD20DEFINITIONS_H_ */
--- a/src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.cpp
+++ 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;
+    }
+  }
+}
--- a/src/fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h
+++ b/src/fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h
@@ -7,13 +7,43 @@

 #include <cstdint>

-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<float> temperature = lp_var_t<float>(sid.objectId, TEMPERATURE_CELCIUS, this);
 };

-}  // namespace MGMLIS3MDL
+}  // namespace mgmLis3

 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_MGMLIS3HANDLERDEFS_H_ */
--- a/src/fsfw_hal/devicehandlers/devicedefinitions/MgmRM3100HandlerDefs.h
+++ b/src/fsfw_hal/devicehandlers/devicedefinitions/MgmRM3100HandlerDefs.h
@@ -8,7 +8,7 @@

 #include <cstdint>

-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<float, 3> fieldStrengths = lp_vec_t<float, 3>(sid.objectId, FIELD_STRENGTHS, this);
 };

-}  // namespace RM3100
+}  // namespace mgmRm3100

 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERRM3100DEFINITIONS_H_ */
--- a/src/fsfw_hal/linux/spi/SpiComIF.h
+++ b/src/fsfw_hal/linux/spi/SpiComIF.h
@@ -90,8 +90,6 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
   * pulled high
   */
  MutexIF* csMutex = nullptr;
-  // MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-  // uint32_t timeoutMs = DEFAULT_MUTEX_TIMEOUT;
  spi_ioc_transfer clockUpdateTransfer = {};

  using SpiDeviceMap = std::unordered_map<address_t, SpiInstance>;
Author	SHA1	Message	Date
Robin Mueller	511d07c0c7	refactored MGM device code	2023-02-26 21:26:24 +01:00
Robin Mueller	cf735143fe	update for SPI/gyro dev handler code	2023-02-26 14:54:35 +01:00
				`@@ -0,0 +1 @@`
				`target_sources(${LIB_FSFW_NAME} PRIVATE gyroL3gHelpers.cpp mgmLis3Helpers.cpp)`