Merge remote-tracking branch 'origin/develop' into mueller/pl-pcdu-update-mode-handling

bsp_q7s/boardconfig/busConf.h

@@ -84,6 +84,7 @@ static constexpr char RS485_EN_TX_DATA[] = "tx_data_enable_ltc2872";
 static constexpr char RS485_EN_RX_CLOCK[] = "rx_clock_enable_ltc2872";
 static constexpr char RS485_EN_RX_DATA[] = "rx_data_enable_ltc2872";
 static constexpr char PDEC_RESET[] = "pdec_reset";
+static constexpr char SYRLINKS_FAULT[] = "syrlinks_fault";
 
 static constexpr char PL_PCDU_ENABLE_VBAT0[] = "enable_plpcdu_vbat0";
 static constexpr char PL_PCDU_ENABLE_VBAT1[] = "enable_plpcdu_vbat1";

bsp_q7s/core/ObjectFactory.cpp

@@ -628,7 +628,7 @@ void ObjectFactory::createSolarArrayDeploymentComponents() {
 void ObjectFactory::createSyrlinksComponents() {
   UartCookie* syrlinksUartCookie =
       new UartCookie(objects::SYRLINKS_HK_HANDLER, q7s::UART_SYRLINKS_DEV, UartModes::NON_CANONICAL,
-                     uart::SYRLINKS_BAUD, SYRLINKS::MAX_REPLY_SIZE);
+                     uart::SYRLINKS_BAUD, syrlinks::MAX_REPLY_SIZE);
   syrlinksUartCookie->setParityEven();
 
   new SyrlinksHkHandler(objects::SYRLINKS_HK_HANDLER, objects::UART_COM_IF, syrlinksUartCookie,

bsp_q7s/core/obsw.cpp

@@ -15,11 +15,7 @@ static int OBSW_ALREADY_RUNNING = -2;
 int obsw::obsw() {
   using namespace fsfw;
   std::cout << "-- EIVE OBSW --" << std::endl;
-#ifdef TE0720_1CFA
-  std::cout << "-- Compiled for Linux (TE0720) --" << std::endl;
-#else
   std::cout << "-- Compiled for Linux (Xiphos Q7S) --" << std::endl;
-#endif
   std::cout << "-- OBSW v" << SW_VERSION << "." << SW_SUBVERSION << "." << SW_REVISION << ", FSFW v"
             << FSFW_VERSION << "--" << std::endl;
   std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;

linux/obc/AxiPtmeConfig.h

@@ -37,6 +37,8 @@ class AxiPtmeConfig : public SystemObject {
    *            The default implementation of the PTME generates a clock where the high level is
    *            only one bit clock period long. This might be too short to match the setup and hold
    *            times of the S-and transceiver.
+   *            Default: Enables TX clock manipulator
+   *
    */
   ReturnValue_t enableTxclockManipulator();
   ReturnValue_t disableTxclockManipulator();
@@ -47,6 +49,7 @@ class AxiPtmeConfig : public SystemObject {
    *        Enable inversion will update data on falling edge (not the configuration required by the
    *        syrlinks)
    *        Disable clock inversion. Data updated on rising edge.
+   *        Default: Inversion is disabled
    */
   ReturnValue_t enableTxclockInversion();
   ReturnValue_t disableTxclockInversion();
@@ -54,7 +57,7 @@ class AxiPtmeConfig : public SystemObject {
  private:
   // Address of register storing the bitrate configuration parameter
   static const uint32_t CADU_BITRATE_REG = 0x0;
-  // Address to register storing common configuration parameters
+  // Address of register storing common configuration parameters
   static const uint32_t COMMON_CONFIG_REG = 0x4;
   static const uint32_t ADRESS_DIVIDER = 4;
 

mission/devices/SyrlinksHkHandler.cpp

@@ -9,17 +9,27 @@ SyrlinksHkHandler::SyrlinksHkHandler(object_id_t objectId, object_id_t comIF, Co
     : DeviceHandlerBase(objectId, comIF, comCookie),
       rxDataset(this),
       txDataset(this),
+      temperatureSet(this),
       powerSwitch(powerSwitch) {
-  if (comCookie == NULL) {
-    sif::error << "SyrlinksHkHandler: Invalid com cookie" << std::endl;
+  if (comCookie == nullptr) {
+    sif::warning << "SyrlinksHkHandler: Invalid com cookie" << std::endl;
   }
 }
 
 SyrlinksHkHandler::~SyrlinksHkHandler() {}
 
 void SyrlinksHkHandler::doStartUp() {
-  if (mode == _MODE_START_UP) {
-    setMode(MODE_ON);
+  switch (startupState) {
+    case StartupState::OFF: {
+      startupState = StartupState::ENABLE_TEMPERATURE_PROTECTION;
+      break;
+    }
+    case StartupState::DONE: {
+      setMode(_MODE_TO_ON);
+      break;
+    }
+    default:
+      break;
   }
 }
 
@@ -27,161 +37,144 @@ void SyrlinksHkHandler::doShutDown() { setMode(_MODE_POWER_DOWN); }
 
 ReturnValue_t SyrlinksHkHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
   switch (nextCommand) {
-    case (SYRLINKS::READ_RX_STATUS_REGISTERS):
-      *id = SYRLINKS::READ_RX_STATUS_REGISTERS;
-      nextCommand = SYRLINKS::READ_TX_STATUS;
+    case (syrlinks::READ_RX_STATUS_REGISTERS):
+      *id = syrlinks::READ_RX_STATUS_REGISTERS;
+      nextCommand = syrlinks::READ_TX_STATUS;
       break;
-    case (SYRLINKS::READ_TX_STATUS):
-      *id = SYRLINKS::READ_TX_STATUS;
-      nextCommand = SYRLINKS::READ_TX_WAVEFORM;
+    case (syrlinks::READ_TX_STATUS):
+      *id = syrlinks::READ_TX_STATUS;
+      nextCommand = syrlinks::READ_TX_WAVEFORM;
       break;
-    case (SYRLINKS::READ_TX_WAVEFORM):
-      *id = SYRLINKS::READ_TX_WAVEFORM;
-      nextCommand = SYRLINKS::READ_TX_AGC_VALUE_HIGH_BYTE;
+    case (syrlinks::READ_TX_WAVEFORM):
+      *id = syrlinks::READ_TX_WAVEFORM;
+      nextCommand = syrlinks::READ_TX_AGC_VALUE_HIGH_BYTE;
       break;
-    case (SYRLINKS::READ_TX_AGC_VALUE_HIGH_BYTE):
-      *id = SYRLINKS::READ_TX_AGC_VALUE_HIGH_BYTE;
-      nextCommand = SYRLINKS::READ_TX_AGC_VALUE_LOW_BYTE;
+    case (syrlinks::READ_TX_AGC_VALUE_HIGH_BYTE):
+      *id = syrlinks::READ_TX_AGC_VALUE_HIGH_BYTE;
+      nextCommand = syrlinks::READ_TX_AGC_VALUE_LOW_BYTE;
       break;
-    case (SYRLINKS::READ_TX_AGC_VALUE_LOW_BYTE):
-      *id = SYRLINKS::READ_TX_AGC_VALUE_LOW_BYTE;
-      nextCommand = SYRLINKS::TEMP_POWER_AMPLIFIER_HIGH_BYTE;
+    case (syrlinks::READ_TX_AGC_VALUE_LOW_BYTE):
+      *id = syrlinks::READ_TX_AGC_VALUE_LOW_BYTE;
+      nextCommand = syrlinks::TEMP_POWER_AMPLIFIER_HIGH_BYTE;
       break;
-    case (SYRLINKS::TEMP_POWER_AMPLIFIER_HIGH_BYTE):
-      *id = SYRLINKS::TEMP_POWER_AMPLIFIER_HIGH_BYTE;
-      nextCommand = SYRLINKS::TEMP_POWER_AMPLIFIER_LOW_BYTE;
+    case (syrlinks::TEMP_POWER_AMPLIFIER_HIGH_BYTE):
+      *id = syrlinks::TEMP_POWER_AMPLIFIER_HIGH_BYTE;
+      nextCommand = syrlinks::TEMP_POWER_AMPLIFIER_LOW_BYTE;
       break;
-    case (SYRLINKS::TEMP_POWER_AMPLIFIER_LOW_BYTE):
-      *id = SYRLINKS::TEMP_POWER_AMPLIFIER_LOW_BYTE;
-      nextCommand = SYRLINKS::TEMP_BASEBAND_BOARD_HIGH_BYTE;
+    case (syrlinks::TEMP_POWER_AMPLIFIER_LOW_BYTE):
+      *id = syrlinks::TEMP_POWER_AMPLIFIER_LOW_BYTE;
+      nextCommand = syrlinks::TEMP_BASEBAND_BOARD_HIGH_BYTE;
       break;
-    case (SYRLINKS::TEMP_BASEBAND_BOARD_HIGH_BYTE):
-      *id = SYRLINKS::TEMP_BASEBAND_BOARD_HIGH_BYTE;
-      nextCommand = SYRLINKS::TEMP_BASEBAND_BOARD_LOW_BYTE;
+    case (syrlinks::TEMP_BASEBAND_BOARD_HIGH_BYTE):
+      *id = syrlinks::TEMP_BASEBAND_BOARD_HIGH_BYTE;
+      nextCommand = syrlinks::TEMP_BASEBAND_BOARD_LOW_BYTE;
       break;
-    case (SYRLINKS::TEMP_BASEBAND_BOARD_LOW_BYTE):
-      *id = SYRLINKS::TEMP_BASEBAND_BOARD_LOW_BYTE;
-      nextCommand = SYRLINKS::READ_RX_STATUS_REGISTERS;
+    case (syrlinks::TEMP_BASEBAND_BOARD_LOW_BYTE):
+      *id = syrlinks::TEMP_BASEBAND_BOARD_LOW_BYTE;
+      nextCommand = syrlinks::READ_RX_STATUS_REGISTERS;
       break;
     default:
       sif::debug << "SyrlinksHkHandler::buildNormalDeviceCommand: rememberCommandId has invalid"
                  << "command id" << std::endl;
       break;
   }
-  return buildCommandFromCommand(*id, NULL, 0);
+  return buildCommandFromCommand(*id, nullptr, 0);
 }
 
 ReturnValue_t SyrlinksHkHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
-  return HasReturnvaluesIF::RETURN_OK;
+  switch (startupState) {
+    case StartupState::ENABLE_TEMPERATURE_PROTECTION: {
+      *id = syrlinks::WRITE_LCL_CONFIG;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    default:
+      break;
+  }
+  return NOTHING_TO_SEND;
 }
 
 ReturnValue_t SyrlinksHkHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                          const uint8_t* commandData,
                                                          size_t commandDataLen) {
   switch (deviceCommand) {
-    case (SYRLINKS::RESET_UNIT): {
-      resetCommand.copy(reinterpret_cast<char*>(commandBuffer), resetCommand.size(), 0);
-      rawPacketLen = resetCommand.size();
-      rawPacket = commandBuffer;
+    case (syrlinks::RESET_UNIT): {
+      prepareCommand(resetCommand, deviceCommand);
       return RETURN_OK;
     }
-    case (SYRLINKS::SET_TX_MODE_STANDBY): {
-      setTxModeStandby.copy(reinterpret_cast<char*>(commandBuffer), setTxModeStandby.size(), 0);
-      rawPacketLen = setTxModeStandby.size();
-      rawPacket = commandBuffer;
+    case (syrlinks::SET_TX_MODE_STANDBY): {
+      prepareCommand(setTxModeStandby, deviceCommand);
       return RETURN_OK;
     }
-    case (SYRLINKS::SET_TX_MODE_MODULATION): {
-      setTxModeModulation.copy(reinterpret_cast<char*>(commandBuffer), setTxModeModulation.size(),
-                               0);
-      rawPacketLen = setTxModeModulation.size();
-      rawPacket = commandBuffer;
+    case (syrlinks::SET_TX_MODE_MODULATION): {
+      prepareCommand(setTxModeModulation, deviceCommand);
       return RETURN_OK;
     }
-    case (SYRLINKS::SET_TX_MODE_CW): {
-      setTxModeCw.copy(reinterpret_cast<char*>(commandBuffer), setTxModeCw.size(), 0);
-      rawPacketLen = setTxModeCw.size();
-      rawPacket = commandBuffer;
+    case (syrlinks::SET_TX_MODE_CW): {
+      prepareCommand(setTxModeCw, deviceCommand);
       return RETURN_OK;
     }
-    case (SYRLINKS::WRITE_LCL_CONFIG): {
-      writeLclConfig.copy(reinterpret_cast<char*>(commandBuffer), writeLclConfig.size(), 0);
-      rawPacketLen = writeLclConfig.size();
-      rawPacket = commandBuffer;
+    case (syrlinks::WRITE_LCL_CONFIG): {
+      prepareCommand(writeLclConfig, deviceCommand);
       return RETURN_OK;
     }
-    case (SYRLINKS::READ_RX_STATUS_REGISTERS): {
-      readRxStatusRegCommand.copy(reinterpret_cast<char*>(commandBuffer),
-                                  readRxStatusRegCommand.size(), 0);
-      rawPacketLen = readRxStatusRegCommand.size();
-      rawPacket = commandBuffer;
+    case (syrlinks::READ_RX_STATUS_REGISTERS): {
+      prepareCommand(readRxStatusRegCommand, deviceCommand);
       return RETURN_OK;
     }
-    case (SYRLINKS::READ_LCL_CONFIG): {
-      readLclConfig.copy(reinterpret_cast<char*>(commandBuffer), readLclConfig.size(), 0);
-      rawPacketLen = readLclConfig.size();
-      rawPacket = commandBuffer;
-      rememberCommandId = SYRLINKS::READ_LCL_CONFIG;
+    case (syrlinks::READ_LCL_CONFIG): {
+      prepareCommand(readLclConfig, deviceCommand);
       return RETURN_OK;
     }
-    case (SYRLINKS::READ_TX_STATUS): {
-      readTxStatus.copy(reinterpret_cast<char*>(commandBuffer), readTxStatus.size(), 0);
-      rawPacketLen = readTxStatus.size();
-      rememberCommandId = SYRLINKS::READ_TX_STATUS;
-      rawPacket = commandBuffer;
+    case (syrlinks::READ_TX_STATUS): {
+      prepareCommand(readTxStatus, deviceCommand);
       return RETURN_OK;
     }
-    case (SYRLINKS::READ_TX_WAVEFORM): {
-      readTxWaveform.copy(reinterpret_cast<char*>(commandBuffer), readTxWaveform.size(), 0);
-      rawPacketLen = readTxWaveform.size();
-      rememberCommandId = SYRLINKS::READ_TX_WAVEFORM;
-      rawPacket = commandBuffer;
+    case (syrlinks::READ_TX_WAVEFORM): {
+      prepareCommand(readTxWaveform, deviceCommand);
       return RETURN_OK;
     }
-    case (SYRLINKS::READ_TX_AGC_VALUE_HIGH_BYTE): {
-      readTxAgcValueHighByte.copy(reinterpret_cast<char*>(commandBuffer),
-                                  readTxAgcValueHighByte.size(), 0);
-      rawPacketLen = readTxAgcValueHighByte.size();
-      rememberCommandId = SYRLINKS::READ_TX_AGC_VALUE_HIGH_BYTE;
-      rawPacket = commandBuffer;
+    case (syrlinks::READ_TX_AGC_VALUE_HIGH_BYTE): {
+      prepareCommand(readTxAgcValueHighByte, deviceCommand);
       return RETURN_OK;
     }
-    case (SYRLINKS::READ_TX_AGC_VALUE_LOW_BYTE): {
-      readTxAgcValueLowByte.copy(reinterpret_cast<char*>(commandBuffer),
-                                 readTxAgcValueLowByte.size(), 0);
-      rawPacketLen = readTxAgcValueLowByte.size();
-      rememberCommandId = SYRLINKS::READ_TX_AGC_VALUE_LOW_BYTE;
-      rawPacket = commandBuffer;
+    case (syrlinks::READ_TX_AGC_VALUE_LOW_BYTE): {
+      prepareCommand(readTxAgcValueLowByte, deviceCommand);
       return RETURN_OK;
     }
-    case (SYRLINKS::TEMP_POWER_AMPLIFIER_HIGH_BYTE):
-      tempPowerAmpBoardHighByte.copy(reinterpret_cast<char*>(commandBuffer),
-                                     tempPowerAmpBoardHighByte.size(), 0);
-      rawPacketLen = tempPowerAmpBoardHighByte.size();
-      rememberCommandId = SYRLINKS::TEMP_POWER_AMPLIFIER_HIGH_BYTE;
-      rawPacket = commandBuffer;
+    case (syrlinks::TEMP_POWER_AMPLIFIER_HIGH_BYTE): {
+      prepareCommand(tempPowerAmpBoardHighByte, deviceCommand);
       return RETURN_OK;
-    case (SYRLINKS::TEMP_POWER_AMPLIFIER_LOW_BYTE):
-      tempPowerAmpBoardLowByte.copy(reinterpret_cast<char*>(commandBuffer),
-                                    tempPowerAmpBoardLowByte.size(), 0);
-      rawPacketLen = tempPowerAmpBoardLowByte.size();
-      rememberCommandId = SYRLINKS::TEMP_POWER_AMPLIFIER_LOW_BYTE;
-      rawPacket = commandBuffer;
+    }
+    case (syrlinks::TEMP_POWER_AMPLIFIER_LOW_BYTE): {
+      prepareCommand(tempPowerAmpBoardLowByte, deviceCommand);
       return RETURN_OK;
-    case (SYRLINKS::TEMP_BASEBAND_BOARD_HIGH_BYTE):
-      tempBasebandBoardHighByte.copy(reinterpret_cast<char*>(commandBuffer),
-                                     tempBasebandBoardHighByte.size(), 0);
-      rawPacketLen = tempBasebandBoardHighByte.size();
-      rememberCommandId = SYRLINKS::TEMP_BASEBAND_BOARD_HIGH_BYTE;
-      rawPacket = commandBuffer;
+    }
+    case (syrlinks::TEMP_BASEBAND_BOARD_HIGH_BYTE): {
+      prepareCommand(tempBasebandBoardHighByte, deviceCommand);
       return RETURN_OK;
-    case (SYRLINKS::TEMP_BASEBAND_BOARD_LOW_BYTE):
-      tempBasebandBoardLowByte.copy(reinterpret_cast<char*>(commandBuffer),
-                                    tempBasebandBoardLowByte.size(), 0);
-      rawPacketLen = tempBasebandBoardLowByte.size();
-      rememberCommandId = SYRLINKS::TEMP_BASEBAND_BOARD_LOW_BYTE;
-      rawPacket = commandBuffer;
+    }
+    case (syrlinks::TEMP_BASEBAND_BOARD_LOW_BYTE): {
+      prepareCommand(tempBasebandBoardLowByte, deviceCommand);
       return RETURN_OK;
+    }
+    case (syrlinks::CONFIG_BPSK): {
+      prepareCommand(configBPSK, deviceCommand);
+      return RETURN_OK;
+    }
+    case (syrlinks::CONFIG_OQPSK): {
+      prepareCommand(configOQPSK, deviceCommand);
+      return RETURN_OK;
+    }
+    case (syrlinks::ENABLE_DEBUG): {
+      debug = true;
+      rawPacketLen = 0;
+      return RETURN_OK;
+    }
+    case (syrlinks::DISABLE_DEBUG): {
+      debug = false;
+      rawPacketLen = 0;
+      return RETURN_OK;
+    }
     default:
       return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
   }
@@ -189,36 +182,42 @@ ReturnValue_t SyrlinksHkHandler::buildCommandFromCommand(DeviceCommandId_t devic
 }
 
 void SyrlinksHkHandler::fillCommandAndReplyMap() {
-  this->insertInCommandAndReplyMap(SYRLINKS::RESET_UNIT, 1, nullptr, SYRLINKS::ACK_SIZE, false,
-                                   true, SYRLINKS::ACK_REPLY);
-  this->insertInCommandAndReplyMap(SYRLINKS::SET_TX_MODE_STANDBY, 1, nullptr, SYRLINKS::ACK_SIZE,
-                                   false, true, SYRLINKS::ACK_REPLY);
-  this->insertInCommandAndReplyMap(SYRLINKS::SET_TX_MODE_MODULATION, 1, nullptr, SYRLINKS::ACK_SIZE,
-                                   false, true, SYRLINKS::ACK_REPLY);
-  this->insertInCommandAndReplyMap(SYRLINKS::SET_TX_MODE_CW, 1, nullptr, SYRLINKS::ACK_SIZE, false,
-                                   true, SYRLINKS::ACK_REPLY);
-  this->insertInCommandAndReplyMap(SYRLINKS::WRITE_LCL_CONFIG, 1, nullptr, SYRLINKS::ACK_SIZE,
-                                   false, true, SYRLINKS::ACK_REPLY);
-  this->insertInCommandAndReplyMap(SYRLINKS::READ_LCL_CONFIG, 1, nullptr,
-                                   SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
-  this->insertInCommandAndReplyMap(SYRLINKS::READ_TX_STATUS, 1, &txDataset,
-                                   SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
-  this->insertInCommandAndReplyMap(SYRLINKS::READ_TX_WAVEFORM, 1, &txDataset,
-                                   SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
-  this->insertInCommandAndReplyMap(SYRLINKS::READ_TX_AGC_VALUE_HIGH_BYTE, 1, &txDataset,
-                                   SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
-  this->insertInCommandAndReplyMap(SYRLINKS::READ_TX_AGC_VALUE_LOW_BYTE, 1, &txDataset,
-                                   SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
-  this->insertInCommandAndReplyMap(SYRLINKS::TEMP_POWER_AMPLIFIER_HIGH_BYTE, 1, nullptr,
-                                   SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
-  this->insertInCommandAndReplyMap(SYRLINKS::TEMP_POWER_AMPLIFIER_LOW_BYTE, 1, nullptr,
-                                   SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
-  this->insertInCommandAndReplyMap(SYRLINKS::TEMP_BASEBAND_BOARD_HIGH_BYTE, 1, nullptr,
-                                   SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
-  this->insertInCommandAndReplyMap(SYRLINKS::TEMP_BASEBAND_BOARD_LOW_BYTE, 1, nullptr,
-                                   SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
-  this->insertInCommandAndReplyMap(SYRLINKS::READ_RX_STATUS_REGISTERS, 1, &rxDataset,
-                                   SYRLINKS::RX_STATUS_REGISTERS_REPLY_SIZE);
+  this->insertInCommandAndReplyMap(syrlinks::RESET_UNIT, 1, nullptr, syrlinks::ACK_SIZE, false,
+                                   true, syrlinks::ACK_REPLY);
+  this->insertInCommandAndReplyMap(syrlinks::SET_TX_MODE_STANDBY, 1, nullptr, syrlinks::ACK_SIZE,
+                                   false, true, syrlinks::ACK_REPLY);
+  this->insertInCommandAndReplyMap(syrlinks::SET_TX_MODE_MODULATION, 1, nullptr, syrlinks::ACK_SIZE,
+                                   false, true, syrlinks::ACK_REPLY);
+  this->insertInCommandAndReplyMap(syrlinks::SET_TX_MODE_CW, 1, nullptr, syrlinks::ACK_SIZE, false,
+                                   true, syrlinks::ACK_REPLY);
+  this->insertInCommandAndReplyMap(syrlinks::WRITE_LCL_CONFIG, 1, nullptr, syrlinks::ACK_SIZE,
+                                   false, true, syrlinks::ACK_REPLY);
+  this->insertInCommandAndReplyMap(syrlinks::CONFIG_BPSK, 1, nullptr, syrlinks::ACK_SIZE,
+                                   false, true, syrlinks::ACK_REPLY);
+  this->insertInCommandAndReplyMap(syrlinks::CONFIG_OQPSK, 1, nullptr, syrlinks::ACK_SIZE,
+                                   false, true, syrlinks::ACK_REPLY);
+  this->insertInCommandMap(syrlinks::ENABLE_DEBUG);
+  this->insertInCommandMap(syrlinks::DISABLE_DEBUG);
+  this->insertInCommandAndReplyMap(syrlinks::READ_LCL_CONFIG, 1, nullptr,
+                                   syrlinks::READ_ONE_REGISTER_REPLY_SIE);
+  this->insertInCommandAndReplyMap(syrlinks::READ_TX_STATUS, 1, &txDataset,
+                                   syrlinks::READ_ONE_REGISTER_REPLY_SIE);
+  this->insertInCommandAndReplyMap(syrlinks::READ_TX_WAVEFORM, 1, &txDataset,
+                                   syrlinks::READ_ONE_REGISTER_REPLY_SIE);
+  this->insertInCommandAndReplyMap(syrlinks::READ_TX_AGC_VALUE_HIGH_BYTE, 1, &txDataset,
+                                   syrlinks::READ_ONE_REGISTER_REPLY_SIE);
+  this->insertInCommandAndReplyMap(syrlinks::READ_TX_AGC_VALUE_LOW_BYTE, 1, &txDataset,
+                                   syrlinks::READ_ONE_REGISTER_REPLY_SIE);
+  this->insertInCommandAndReplyMap(syrlinks::TEMP_POWER_AMPLIFIER_HIGH_BYTE, 1, nullptr,
+                                   syrlinks::READ_ONE_REGISTER_REPLY_SIE);
+  this->insertInCommandAndReplyMap(syrlinks::TEMP_POWER_AMPLIFIER_LOW_BYTE, 1, nullptr,
+                                   syrlinks::READ_ONE_REGISTER_REPLY_SIE);
+  this->insertInCommandAndReplyMap(syrlinks::TEMP_BASEBAND_BOARD_HIGH_BYTE, 1, nullptr,
+                                   syrlinks::READ_ONE_REGISTER_REPLY_SIE);
+  this->insertInCommandAndReplyMap(syrlinks::TEMP_BASEBAND_BOARD_LOW_BYTE, 1, nullptr,
+                                   syrlinks::READ_ONE_REGISTER_REPLY_SIE);
+  this->insertInCommandAndReplyMap(syrlinks::READ_RX_STATUS_REGISTERS, 1, &rxDataset,
+                                   syrlinks::RX_STATUS_REGISTERS_REPLY_SIZE);
 }
 
 ReturnValue_t SyrlinksHkHandler::scanForReply(const uint8_t* start, size_t remainingSize,
@@ -226,25 +225,25 @@ ReturnValue_t SyrlinksHkHandler::scanForReply(const uint8_t* start, size_t remai
   ReturnValue_t result = RETURN_OK;
 
   if (*start != '<') {
-    sif::error << "SyrlinksHkHandler::scanForReply: Missing start frame character" << std::endl;
+    sif::warning << "SyrlinksHkHandler::scanForReply: Missing start frame character" << std::endl;
     return MISSING_START_FRAME_CHARACTER;
   }
 
   switch (*(start + 1)) {
     case ('A'):
-      *foundLen = SYRLINKS::ACK_SIZE;
-      *foundId = SYRLINKS::ACK_REPLY;
+      *foundLen = syrlinks::ACK_SIZE;
+      *foundId = syrlinks::ACK_REPLY;
       break;
     case ('E'):
-      *foundLen = SYRLINKS::RX_STATUS_REGISTERS_REPLY_SIZE;
-      *foundId = SYRLINKS::READ_RX_STATUS_REGISTERS;
+      *foundLen = syrlinks::RX_STATUS_REGISTERS_REPLY_SIZE;
+      *foundId = syrlinks::READ_RX_STATUS_REGISTERS;
       break;
     case ('R'):
       *foundId = rememberCommandId;
-      *foundLen = SYRLINKS::READ_ONE_REGISTER_REPLY_SIE;
+      *foundLen = syrlinks::READ_ONE_REGISTER_REPLY_SIE;
       break;
     default:
-      sif::error << "SyrlinksHkHandler::scanForReply: Unknown reply identifier" << std::endl;
+      sif::warning << "SyrlinksHkHandler::scanForReply: Unknown reply identifier" << std::endl;
       result = IGNORE_REPLY_DATA;
       break;
   }
@@ -265,124 +264,156 @@ ReturnValue_t SyrlinksHkHandler::interpretDeviceReply(DeviceCommandId_t id, cons
   ReturnValue_t result;
 
   switch (id) {
-    case (SYRLINKS::ACK_REPLY):
-      result = verifyReply(packet, SYRLINKS::ACK_SIZE);
+    case (syrlinks::ACK_REPLY): {
+      result = verifyReply(packet, syrlinks::ACK_SIZE);
       if (result != RETURN_OK) {
-        sif::error << "SyrlinksHkHandler::interpretDeviceReply: Acknowledgment reply has "
-                      "invalid crc"
-                   << std::endl;
+        sif::warning << "SyrlinksHkHandler::interpretDeviceReply: Acknowledgment reply has "
+                        "invalid crc"
+                     << std::endl;
         return CRC_FAILURE;
       }
-      result =
-          parseReplyStatus(reinterpret_cast<const char*>(packet + SYRLINKS::MESSAGE_HEADER_SIZE));
+      result = handleAckReply(packet);
       if (result != RETURN_OK) {
         return result;
       }
       break;
-    case (SYRLINKS::READ_RX_STATUS_REGISTERS):
-      result = verifyReply(packet, SYRLINKS::RX_STATUS_REGISTERS_REPLY_SIZE);
+    }
+    case (syrlinks::READ_RX_STATUS_REGISTERS): {
+      result = verifyReply(packet, syrlinks::RX_STATUS_REGISTERS_REPLY_SIZE);
       if (result != RETURN_OK) {
-        sif::error << "SyrlinksHkHandler::interpretDeviceReply: Read rx status registers reply "
-                   << "has invalid crc" << std::endl;
+        sif::warning << "SyrlinksHkHandler::interpretDeviceReply: Read rx status registers reply "
+                     << "has invalid crc" << std::endl;
         return CRC_FAILURE;
       }
       parseRxStatusRegistersReply(packet);
       break;
-    case (SYRLINKS::READ_LCL_CONFIG):
-      result = verifyReply(packet, SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
+    }
+    case (syrlinks::READ_LCL_CONFIG): {
+      result = verifyReply(packet, syrlinks::READ_ONE_REGISTER_REPLY_SIE);
       if (result != RETURN_OK) {
-        sif::error << "SyrlinksHkHandler::interpretDeviceReply: Read config lcl reply "
-                   << "has invalid crc" << std::endl;
+        sif::warning << "SyrlinksHkHandler::interpretDeviceReply: Read config lcl reply "
+                     << "has invalid crc" << std::endl;
         return CRC_FAILURE;
       }
       parseLclConfigReply(packet);
       break;
-    case (SYRLINKS::READ_TX_STATUS):
-      result = verifyReply(packet, SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
+    }
+    case (syrlinks::READ_TX_STATUS): {
+      result = verifyReply(packet, syrlinks::READ_ONE_REGISTER_REPLY_SIE);
       if (result != RETURN_OK) {
-        sif::error << "SyrlinksHkHandler::interpretDeviceReply: Read tx status reply "
-                   << "has invalid crc" << std::endl;
+        sif::warning << "SyrlinksHkHandler::interpretDeviceReply: Read tx status reply "
+                     << "has invalid crc" << std::endl;
         return CRC_FAILURE;
       }
       parseTxStatusReply(packet);
       break;
-    case (SYRLINKS::READ_TX_WAVEFORM):
-      result = verifyReply(packet, SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
+    }
+    case (syrlinks::READ_TX_WAVEFORM): {
+      result = verifyReply(packet, syrlinks::READ_ONE_REGISTER_REPLY_SIE);
       if (result != RETURN_OK) {
-        sif::error << "SyrlinksHkHandler::interpretDeviceReply: Read tx waveform reply "
-                   << "has invalid crc" << std::endl;
+        sif::warning << "SyrlinksHkHandler::interpretDeviceReply: Read tx waveform reply "
+                     << "has invalid crc" << std::endl;
         return CRC_FAILURE;
       }
       parseTxWaveformReply(packet);
       break;
-    case (SYRLINKS::READ_TX_AGC_VALUE_HIGH_BYTE):
-      result = verifyReply(packet, SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
+    }
+    case (syrlinks::READ_TX_AGC_VALUE_HIGH_BYTE): {
+      result = verifyReply(packet, syrlinks::READ_ONE_REGISTER_REPLY_SIE);
       if (result != RETURN_OK) {
-        sif::error << "SyrlinksHkHandler::interpretDeviceReply: Read tx AGC high byte reply "
-                   << "has invalid crc" << std::endl;
+        sif::warning << "SyrlinksHkHandler::interpretDeviceReply: Read tx AGC high byte reply "
+                     << "has invalid crc" << std::endl;
         return CRC_FAILURE;
       }
       parseAgcHighByte(packet);
       break;
-    case (SYRLINKS::READ_TX_AGC_VALUE_LOW_BYTE):
-      result = verifyReply(packet, SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
+    }
+    case (syrlinks::READ_TX_AGC_VALUE_LOW_BYTE): {
+      result = verifyReply(packet, syrlinks::READ_ONE_REGISTER_REPLY_SIE);
       if (result != RETURN_OK) {
-        sif::error << "SyrlinksHkHandler::interpretDeviceReply: Read tx AGC low byte reply "
-                   << "has invalid crc" << std::endl;
+        sif::warning << "SyrlinksHkHandler::interpretDeviceReply: Read tx AGC low byte reply "
+                     << "has invalid crc" << std::endl;
         return CRC_FAILURE;
       }
       parseAgcLowByte(packet);
       break;
-    case (SYRLINKS::TEMP_BASEBAND_BOARD_HIGH_BYTE):
-      result = verifyReply(packet, SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
+    }
+    case (syrlinks::TEMP_BASEBAND_BOARD_HIGH_BYTE): {
+      result = verifyReply(packet, syrlinks::READ_ONE_REGISTER_REPLY_SIE);
       if (result != RETURN_OK) {
-        sif::error << "SyrlinksHkHandler::interpretDeviceReply: Read temperature baseband board "
-                   << "high byte reply has invalid crc" << std::endl;
+        sif::warning << "SyrlinksHkHandler::interpretDeviceReply: Read temperature baseband board "
+                     << "high byte reply has invalid crc" << std::endl;
         return CRC_FAILURE;
       }
       rawTempBasebandBoard = convertHexStringToUint8(reinterpret_cast<const char*>(
-                                 packet + SYRLINKS::MESSAGE_HEADER_SIZE))
+                                 packet + syrlinks::MESSAGE_HEADER_SIZE))
                              << 8;
       break;
-    case (SYRLINKS::TEMP_BASEBAND_BOARD_LOW_BYTE):
-      result = verifyReply(packet, SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
+    }
+    case (syrlinks::TEMP_BASEBAND_BOARD_LOW_BYTE): {
+      result = verifyReply(packet, syrlinks::READ_ONE_REGISTER_REPLY_SIE);
       if (result != RETURN_OK) {
-        sif::error << "SyrlinksHkHandler::interpretDeviceReply: Read temperature baseband board"
-                      " low byte reply has invalid crc"
-                   << std::endl;
+        sif::warning << "SyrlinksHkHandler::interpretDeviceReply: Read temperature baseband board"
+                        " low byte reply has invalid crc"
+                     << std::endl;
         return CRC_FAILURE;
       }
       rawTempBasebandBoard |= convertHexStringToUint8(
-          reinterpret_cast<const char*>(packet + SYRLINKS::MESSAGE_HEADER_SIZE));
+          reinterpret_cast<const char*>(packet + syrlinks::MESSAGE_HEADER_SIZE));
       tempBasebandBoard = calcTempVal(rawTempBasebandBoard);
+<<<<<<< HEAD
       sif::info << "Syrlinks temperature baseband board: " << tempBasebandBoard << "  °C"
                 << std::endl;
+=======
+      temperatureSet.temperatureBasebandBoard = tempBasebandBoard;
+      PoolReadGuard rg(&temperatureSet);
+      if (debug) {
+        sif::info << "Syrlinks temperature baseband board: " << tempBasebandBoard << "  °C"
+                  << std::endl;
+      }
+>>>>>>> origin/develop
       break;
-    case (SYRLINKS::TEMP_POWER_AMPLIFIER_HIGH_BYTE):
-      result = verifyReply(packet, SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
+    }
+    case (syrlinks::TEMP_POWER_AMPLIFIER_HIGH_BYTE): {
+      result = verifyReply(packet, syrlinks::READ_ONE_REGISTER_REPLY_SIE);
       if (result != RETURN_OK) {
-        sif::error << "SyrlinksHkHandler::interpretDeviceReply: Read temperature power amplifier "
-                   << "board high byte reply has invalid crc" << std::endl;
+        sif::warning << "SyrlinksHkHandler::interpretDeviceReply: Read temperature power amplifier "
+                     << "board high byte reply has invalid crc" << std::endl;
         return CRC_FAILURE;
       }
       rawTempPowerAmplifier = 0;
       rawTempPowerAmplifier = convertHexStringToUint8(reinterpret_cast<const char*>(
+<<<<<<< HEAD
                                   packet + SYRLINKS::MESSAGE_HEADER_SIZE))
+=======
+                                  packet + syrlinks::MESSAGE_HEADER_SIZE))
+>>>>>>> origin/develop
                               << 8;
       break;
-    case (SYRLINKS::TEMP_POWER_AMPLIFIER_LOW_BYTE):
-      result = verifyReply(packet, SYRLINKS::READ_ONE_REGISTER_REPLY_SIE);
+    }
+    case (syrlinks::TEMP_POWER_AMPLIFIER_LOW_BYTE): {
+      result = verifyReply(packet, syrlinks::READ_ONE_REGISTER_REPLY_SIE);
       if (result != RETURN_OK) {
-        sif::error << "SyrlinksHkHandler::interpretDeviceReply: Read temperature power amplifier"
-                   << " board low byte reply has invalid crc" << std::endl;
+        sif::warning << "SyrlinksHkHandler::interpretDeviceReply: Read temperature power amplifier"
+                     << " board low byte reply has invalid crc" << std::endl;
         return CRC_FAILURE;
       }
       rawTempPowerAmplifier |= convertHexStringToUint8(
-          reinterpret_cast<const char*>(packet + SYRLINKS::MESSAGE_HEADER_SIZE));
+          reinterpret_cast<const char*>(packet + syrlinks::MESSAGE_HEADER_SIZE));
       tempPowerAmplifier = calcTempVal(rawTempPowerAmplifier);
+<<<<<<< HEAD
       sif::info << "Syrlinks temperature power amplifier board: " << tempPowerAmplifier << "  °C"
                 << std::endl;
+=======
+      PoolReadGuard rg(&temperatureSet);
+      temperatureSet.temperaturePowerAmplifier = tempPowerAmplifier;
+      if (debug) {
+        sif::info << "Syrlinks temperature power amplifier board: " << tempPowerAmplifier << "  °C"
+                  << std::endl;
+      }
+>>>>>>> origin/develop
       break;
+    }
     default: {
       sif::debug << "SyrlinksHkHandler::interpretDeviceReply: Unknown device reply id" << std::endl;
       return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
@@ -397,8 +428,10 @@ LocalPoolDataSetBase* SyrlinksHkHandler::getDataSetHandle(sid_t sid) {
     return &rxDataset;
   } else if (sid == txDataset.getSid()) {
     return &txDataset;
+  } else if (sid == temperatureSet.getSid()) {
+    return &temperatureSet;
   } else {
-    sif::error << "SyrlinksHkHandler::getDataSetHandle: Invalid sid" << std::endl;
+    sif::warning << "SyrlinksHkHandler::getDataSetHandle: Invalid sid" << std::endl;
     return nullptr;
   }
 }
@@ -452,7 +485,7 @@ ReturnValue_t SyrlinksHkHandler::parseReplyStatus(const char* status) {
     case '0':
       return RETURN_OK;
     case '1':
-      sif::debug << "SyrlinksHkHandler::parseReplyStatus: Uart faming or parity error" << std::endl;
+      sif::debug << "SyrlinksHkHandler::parseReplyStatus: Uart framing or parity error" << std::endl;
       return UART_FRAMIN_OR_PARITY_ERROR_ACK;
     case '2':
       sif::debug << "SyrlinksHkHandler::parseReplyStatus: Bad character detected" << std::endl;
@@ -482,11 +515,11 @@ ReturnValue_t SyrlinksHkHandler::verifyReply(const uint8_t* packet, uint8_t size
   int result = 0;
   /* Calculate crc from received packet */
   uint16_t crc =
-      CRC::crc16ccitt(packet, size - SYRLINKS::SIZE_CRC_AND_TERMINATION, CRC_INITIAL_VALUE);
+      CRC::crc16ccitt(packet, size - syrlinks::SIZE_CRC_AND_TERMINATION, CRC_INITIAL_VALUE);
   std::string recalculatedCrc = convertUint16ToHexString(crc);
 
   const char* startOfCrc =
-      reinterpret_cast<const char*>(packet + size - SYRLINKS::SIZE_CRC_AND_TERMINATION);
+      reinterpret_cast<const char*>(packet + size - syrlinks::SIZE_CRC_AND_TERMINATION);
   const char* endOfCrc = reinterpret_cast<const char*>(packet + size - 1);
 
   std::string replyCrc(startOfCrc, endOfCrc);
@@ -500,7 +533,7 @@ ReturnValue_t SyrlinksHkHandler::verifyReply(const uint8_t* packet, uint8_t size
 
 void SyrlinksHkHandler::parseRxStatusRegistersReply(const uint8_t* packet) {
   PoolReadGuard readHelper(&rxDataset);
-  uint16_t offset = SYRLINKS::MESSAGE_HEADER_SIZE;
+  uint16_t offset = syrlinks::MESSAGE_HEADER_SIZE;
   rxDataset.rxStatus = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
   offset += 2;
   rxDataset.rxSensitivity =
@@ -521,58 +554,68 @@ void SyrlinksHkHandler::parseRxStatusRegistersReply(const uint8_t* packet) {
   rxDataset.rxDataRate = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
 
 #if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_SYRLINKS == 1
-  sif::info << "Syrlinks RX Status: 0x" << std::hex << (unsigned int)rxDataset.rxStatus.value
-            << std::endl;
-  sif::info << "Syrlinks RX Sensitivity: " << std::dec << rxDataset.rxSensitivity << std::endl;
-  sif::info << "Syrlinks RX Frequency Shift: " << rxDataset.rxFrequencyShift << std::endl;
-  sif::info << "Syrlinks RX IQ Power: " << rxDataset.rxIqPower << std::endl;
-  sif::info << "Syrlinks RX AGC Value: " << rxDataset.rxAgcValue << std::endl;
-  sif::info << "Syrlinks RX Demod Eb: " << rxDataset.rxDemodEb << std::endl;
-  sif::info << "Syrlinks RX Demod N0: " << rxDataset.rxDemodN0 << std::endl;
-  sif::info << "Syrlinks RX Datarate: " << (unsigned int)rxDataset.rxDataRate.value << std::endl;
+  if (debug) {
+      sif::info << "Syrlinks RX Status: 0x" << std::hex << (unsigned int)rxDataset.rxStatus.value
+                << std::endl;
+      sif::info << "Syrlinks RX Sensitivity: " << std::dec << rxDataset.rxSensitivity << std::endl;
+      sif::info << "Syrlinks RX Frequency Shift: " << rxDataset.rxFrequencyShift << std::endl;
+      sif::info << "Syrlinks RX IQ Power: " << rxDataset.rxIqPower << std::endl;
+      sif::info << "Syrlinks RX AGC Value: " << rxDataset.rxAgcValue << std::endl;
+      sif::info << "Syrlinks RX Demod Eb: " << rxDataset.rxDemodEb << std::endl;
+      sif::info << "Syrlinks RX Demod N0: " << rxDataset.rxDemodN0 << std::endl;
+      sif::info << "Syrlinks RX Datarate: " << (unsigned int)rxDataset.rxDataRate.value << std::endl;
+  }
 #endif
 }
 
 void SyrlinksHkHandler::parseLclConfigReply(const uint8_t* packet) {
-  uint16_t offset = SYRLINKS::MESSAGE_HEADER_SIZE;
+  uint16_t offset = syrlinks::MESSAGE_HEADER_SIZE;
   uint8_t lclConfig = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
-  sif::info << "SyrlinksHkHandler::parseRxStatusRegistersReply: Lcl config: "
-            << static_cast<unsigned int>(lclConfig) << std::endl;
+  if (debug) {
+      sif::info << "SyrlinksHkHandler::parseRxStatusRegistersReply: Lcl config: "
+                << static_cast<unsigned int>(lclConfig) << std::endl;
+  }
 }
 
 void SyrlinksHkHandler::parseTxStatusReply(const uint8_t* packet) {
   PoolReadGuard readHelper(&txDataset);
-  uint16_t offset = SYRLINKS::MESSAGE_HEADER_SIZE;
+  uint16_t offset = syrlinks::MESSAGE_HEADER_SIZE;
   txDataset.txStatus = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
-#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_SYRLINKS == 1
+#if OBSW_DEBUG_SYRLINKS == 1
+  if (debug) {
   sif::info << "Syrlinks TX Status: 0x" << std::hex << (unsigned int)txDataset.txStatus.value
             << std::endl;
+  }
 #endif
 }
 
 void SyrlinksHkHandler::parseTxWaveformReply(const uint8_t* packet) {
   PoolReadGuard readHelper(&txDataset);
-  uint16_t offset = SYRLINKS::MESSAGE_HEADER_SIZE;
+  uint16_t offset = syrlinks::MESSAGE_HEADER_SIZE;
   txDataset.txWaveform = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
-#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_SYRLINKS == 1
+#if OBSW_DEBUG_SYRLINKS == 1
+  if (debug) {
   sif::info << "Syrlinks TX Waveform: 0x" << std::hex << (unsigned int)txDataset.txWaveform.value
             << std::endl;
+  }
 #endif
 }
 
 void SyrlinksHkHandler::parseAgcLowByte(const uint8_t* packet) {
   PoolReadGuard readHelper(&txDataset);
-  uint16_t offset = SYRLINKS::MESSAGE_HEADER_SIZE;
+  uint16_t offset = syrlinks::MESSAGE_HEADER_SIZE;
   txDataset.txAgcValue = agcValueHighByte << 8 |
                          convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
-#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_SYRLINKS == 1
-  sif::info << "Syrlinks TX AGC Value: " << txDataset.txAgcValue << std::endl;
+#if OBSW_DEBUG_SYRLINKS == 1
+  if (debug) {
+      sif::info << "Syrlinks TX AGC Value: " << txDataset.txAgcValue << std::endl;
+  }
 #endif
 }
 
 void SyrlinksHkHandler::parseAgcHighByte(const uint8_t* packet) {
   PoolReadGuard readHelper(&txDataset);
-  uint16_t offset = SYRLINKS::MESSAGE_HEADER_SIZE;
+  uint16_t offset = syrlinks::MESSAGE_HEADER_SIZE;
   agcValueHighByte = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
 }
 
@@ -582,18 +625,20 @@ uint32_t SyrlinksHkHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo)
 
 ReturnValue_t SyrlinksHkHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                          LocalDataPoolManager& poolManager) {
-  localDataPoolMap.emplace(SYRLINKS::RX_STATUS, new PoolEntry<uint8_t>({0}));
-  localDataPoolMap.emplace(SYRLINKS::RX_SENSITIVITY, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(SYRLINKS::RX_FREQUENCY_SHIFT, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(SYRLINKS::RX_IQ_POWER, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(SYRLINKS::RX_AGC_VALUE, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(SYRLINKS::RX_DEMOD_EB, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(SYRLINKS::RX_DEMOD_N0, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(SYRLINKS::RX_DATA_RATE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(syrlinks::RX_STATUS, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(syrlinks::RX_SENSITIVITY, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(syrlinks::RX_FREQUENCY_SHIFT, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(syrlinks::RX_IQ_POWER, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(syrlinks::RX_AGC_VALUE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(syrlinks::RX_DEMOD_EB, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(syrlinks::RX_DEMOD_N0, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(syrlinks::RX_DATA_RATE, new PoolEntry<uint8_t>({0}));
 
-  localDataPoolMap.emplace(SYRLINKS::TX_STATUS, new PoolEntry<uint8_t>({0}));
-  localDataPoolMap.emplace(SYRLINKS::TX_WAVEFORM, new PoolEntry<uint8_t>({0}));
-  localDataPoolMap.emplace(SYRLINKS::TX_AGC_VALUE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(syrlinks::TX_STATUS, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(syrlinks::TX_WAVEFORM, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(syrlinks::TX_AGC_VALUE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(syrlinks::TEMP_BASEBAND_BOARD, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(syrlinks::TEMP_POWER_AMPLIFIER, new PoolEntry<uint16_t>({0}));
 
   return HasReturnvaluesIF::RETURN_OK;
 }
@@ -601,3 +646,21 @@ ReturnValue_t SyrlinksHkHandler::initializeLocalDataPool(localpool::DataPool& lo
 void SyrlinksHkHandler::setModeNormal() { mode = MODE_NORMAL; }
 
 float SyrlinksHkHandler::calcTempVal(uint16_t raw) { return 0.126984 * raw - 67.87; }
+
+ReturnValue_t SyrlinksHkHandler::handleAckReply(const uint8_t* packet) {
+  ReturnValue_t result =
+      parseReplyStatus(reinterpret_cast<const char*>(packet + syrlinks::MESSAGE_HEADER_SIZE));
+  if (rememberCommandId == syrlinks::WRITE_LCL_CONFIG and result != RETURN_OK) {
+    startupState = StartupState::OFF;
+  } else if (rememberCommandId == syrlinks::WRITE_LCL_CONFIG and result == RETURN_OK) {
+    startupState = StartupState::DONE;
+  }
+  return result;
+}
+
+void SyrlinksHkHandler::prepareCommand(std::string command, DeviceCommandId_t commandId) {
+  command.copy(reinterpret_cast<char*>(commandBuffer), command.size(), 0);
+  rawPacketLen = command.size();
+  rememberCommandId = commandId;
+  rawPacket = commandBuffer;
+}

mission/devices/SyrlinksHkHandler.h

@@ -6,6 +6,9 @@
 #include "devices/powerSwitcherList.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "mission/devices/devicedefinitions/SyrlinksDefinitions.h"
+#include "fsfw_hal/linux/gpio/Gpio.h"
+#include "fsfw/timemanager/Countdown.h"
+#include <string.h>
 
 /**
  * @brief	This is the device handler for the syrlinks transceiver. It handles the command
@@ -65,8 +68,12 @@ class SyrlinksHkHandler : public DeviceHandlerBase {
   std::string setTxModeStandby = "<W04:4000:7E58>";
   /** W - write, 04 - 4 bytes in data field, 01 - value, 40 register to write value */
   std::string setTxModeModulation = "<W04:4001:4D69>";
+  std::string configBPSK = "<W04:4007:E7CF>";
+  std::string configOQPSK = "<W04:400B:1063>";
   std::string setTxModeCw = "<W04:4010:4968>";
   std::string writeLclConfig = "<W04:0707:3FE4>";
+  std::string setWaveformOQPSK = "<W04:4403:E1FA>";
+  std::string setWaveformBPSK = "<W04:4406:1E0F>";
   std::string readTxStatus = "<R02:40:7555>";
   std::string readTxWaveform = "<R02:44:B991>";
   std::string readTxAgcValueHighByte = "<R02:46:DFF3>";
@@ -81,10 +88,11 @@ class SyrlinksHkHandler : public DeviceHandlerBase {
    * In some cases it is not possible to extract from the received reply the information about
    * the associated command. This variable is thus used to remember the command id.
    */
-  DeviceCommandId_t rememberCommandId = SYRLINKS::NONE;
+  DeviceCommandId_t rememberCommandId = syrlinks::NONE;
 
-  SYRLINKS::RxDataset rxDataset;
-  SYRLINKS::TxDataset txDataset;
+  syrlinks::RxDataset rxDataset;
+  syrlinks::TxDataset txDataset;
+  syrlinks::TemperatureSet temperatureSet;
 
   const power::Switch_t powerSwitch = power::NO_SWITCH;
 
@@ -94,13 +102,23 @@ class SyrlinksHkHandler : public DeviceHandlerBase {
   float tempPowerAmplifier = 0;
   float tempBasebandBoard = 0;
 
-  uint8_t commandBuffer[SYRLINKS::MAX_COMMAND_SIZE];
+  uint8_t commandBuffer[syrlinks::MAX_COMMAND_SIZE];
+
+  enum class StartupState {
+      OFF,
+      ENABLE_TEMPERATURE_PROTECTION,
+      DONE
+  };
+
+  StartupState startupState = StartupState::OFF;
+
+  bool debug = false;
 
   /**
    * This object is used to store the id of the next command to execute. This controls the
    * read out of multiple registers which can not be fetched with one single command.
    */
-  DeviceCommandId_t nextCommand = SYRLINKS::READ_RX_STATUS_REGISTERS;
+  DeviceCommandId_t nextCommand = syrlinks::READ_RX_STATUS_REGISTERS;
 
   /**
    * @brief   This function converts an uint16_t into its hexadecimal string representation.
@@ -193,6 +211,10 @@ class SyrlinksHkHandler : public DeviceHandlerBase {
    * @brief Calculates temperature in degree celcius form raw value
    */
   float calcTempVal(uint16_t);
+
+  ReturnValue_t handleAckReply(const uint8_t* packet);
+
+  void prepareCommand(std::string command, DeviceCommandId_t commandId);
 };
 
 #endif /* MISSION_DEVICES_SYRLINKSHKHANDLER_H_ */

mission/devices/devicedefinitions/SyrlinksDefinitions.h

@@ -1,7 +1,7 @@
 #ifndef MISSION_DEVICES_DEVICEDEFINITIONS_SYRLINKSDEFINITIONS_H_
 #define MISSION_DEVICES_DEVICEDEFINITIONS_SYRLINKSDEFINITIONS_H_
 
-namespace SYRLINKS {
+namespace syrlinks {
 
 static const DeviceCommandId_t NONE = 0;
 static const DeviceCommandId_t RESET_UNIT = 1;
@@ -24,6 +24,11 @@ static const DeviceCommandId_t TEMP_POWER_AMPLIFIER_HIGH_BYTE = 13;
 static const DeviceCommandId_t TEMP_POWER_AMPLIFIER_LOW_BYTE = 14;
 static const DeviceCommandId_t TEMP_BASEBAND_BOARD_HIGH_BYTE = 15;
 static const DeviceCommandId_t TEMP_BASEBAND_BOARD_LOW_BYTE = 16;
+static const DeviceCommandId_t CONFIG_OQPSK = 17;
+// After startup syrlinks always in BSPK configuration
+static const DeviceCommandId_t CONFIG_BPSK = 18;
+static const DeviceCommandId_t ENABLE_DEBUG = 20;
+static const DeviceCommandId_t DISABLE_DEBUG = 21;
 
 /** Size of a simple transmission success response */
 static const uint8_t ACK_SIZE = 12;
@@ -36,6 +41,7 @@ static const uint8_t READ_ONE_REGISTER_REPLY_SIE = 13;
 
 static const uint8_t RX_DATASET_ID = 0x1;
 static const uint8_t TX_DATASET_ID = 0x2;
+static const uint8_t TEMPERATURE_SET_ID = 0x3;
 
 static const size_t MAX_REPLY_SIZE = RX_STATUS_REGISTERS_REPLY_SIZE;
 static const size_t MAX_COMMAND_SIZE = 15;
@@ -44,6 +50,7 @@ static const size_t CRC_FIELD_SIZE = 4;
 
 static const uint8_t RX_DATASET_SIZE = 8;
 static const uint8_t TX_DATASET_SIZE = 3;
+static const uint8_t TEMPERATURE_SET_SIZE = 3;
 
 enum SyrlinksPoolIds : lp_id_t {
   RX_STATUS,
@@ -60,6 +67,8 @@ enum SyrlinksPoolIds : lp_id_t {
   TX_WAVEFORM,
   TX_PCM_INDEX,
   TX_AGC_VALUE,
+  TEMP_POWER_AMPLIFIER,
+  TEMP_BASEBAND_BOARD
 };
 
 class RxDataset : public StaticLocalDataSet<RX_DATASET_SIZE> {
@@ -89,6 +98,18 @@ class TxDataset : public StaticLocalDataSet<TX_DATASET_SIZE> {
   lp_var_t<uint16_t> txAgcValue = lp_var_t<uint16_t>(sid.objectId, TX_AGC_VALUE, this);
 };
 
-}  // namespace SYRLINKS
+class TemperatureSet : public StaticLocalDataSet<TEMPERATURE_SET_SIZE> {
+ public:
+  TemperatureSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TEMPERATURE_SET_ID) {}
+
+  TemperatureSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, TEMPERATURE_SET_ID)) {}
+
+  lp_var_t<uint16_t> temperaturePowerAmplifier =
+      lp_var_t<uint16_t>(sid.objectId, TEMP_POWER_AMPLIFIER, this);
+  lp_var_t<uint16_t> temperatureBasebandBoard =
+      lp_var_t<uint16_t>(sid.objectId, TEMP_BASEBAND_BOARD, this);
+};
+
+}  // namespace syrlinks
 
 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_SYRLINKSDEFINITIONS_H_ */

mission/tmtc/CCSDSHandler.h

@@ -91,9 +91,9 @@ class CCSDSHandler : public SystemObject,
   static const ActionId_t ARBITRARY_RATE = 4;
   static const ActionId_t ENABLE_TX_CLK_MANIPULATOR = 5;
   static const ActionId_t DISABLE_TX_CLK_MANIPULATOR = 6;
-  // Will update data with respect to tx clock signal of cadu bitsream on rising edge
+  // Will update data with respect to tx clock signal of cadu bitstream on rising edge
   static const ActionId_t UPDATE_ON_RISING_EDGE = 7;
-  // Will update data with respect to tx clock signal of cadu bitsream on falling edge
+  // Will update data with respect to tx clock signal of cadu bitstream on falling edge
   static const ActionId_t UPDATE_ON_FALLING_EDGE = 8;
 
   // Syrlinks supports two bitrates (200 kbps and 1000 kbps)