refactored star tracker handler

2022-02-27 15:46:06 +01:00 · 2022-02-27 15:46:06 +01:00 · dfd817d27b
commit dfd817d27b
parent e61dfc0401
12 changed files with 87 additions and 3205 deletions
--- a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp
+++ b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 09c1918c1fe36a07ce611a33ff20799187d8d962
+Subproject commit eacb4ac4079ff2bf5e0648626332e59046a409da
--- a/generators/bsp_q7s_events.csv
+++ b/generators/bsp_q7s_events.csv
@ -82,11 +82,11 @@
 10902;SWITCH_ALREADY_ON;LOW;;C:\Users\jakob\eive-software\eive_obsw/mission/devices/HeaterHandler.h
 10903;SWITCH_ALREADY_OFF;LOW;;C:\Users\jakob\eive-software\eive_obsw/mission/devices/HeaterHandler.h
 10904;MAIN_SWITCH_TIMEOUT;LOW;;C:\Users\jakob\eive-software\eive_obsw/mission/devices/HeaterHandler.h
-11000;MAIN_SWITCH_ON_TIMEOUT;LOW;;C:\Users\jakob\eive-software\eive_obsw/linux/devices/SolarArrayDeploymentHandler.h
+11000;MAIN_SWITCH_ON_TIMEOUT;LOW;;C:\Users\jakob\eive-software\eive_obsw/mission/devices/SolarArrayDeploymentHandler.h
-11001;MAIN_SWITCH_OFF_TIMEOUT;LOW;;C:\Users\jakob\eive-software\eive_obsw/linux/devices/SolarArrayDeploymentHandler.h
+11001;MAIN_SWITCH_OFF_TIMEOUT;LOW;;C:\Users\jakob\eive-software\eive_obsw/mission/devices/SolarArrayDeploymentHandler.h
-11002;DEPLOYMENT_FAILED;HIGH;;C:\Users\jakob\eive-software\eive_obsw/linux/devices/SolarArrayDeploymentHandler.h
+11002;DEPLOYMENT_FAILED;HIGH;;C:\Users\jakob\eive-software\eive_obsw/mission/devices/SolarArrayDeploymentHandler.h
-11003;DEPL_SA1_GPIO_SWTICH_ON_FAILED;HIGH;;C:\Users\jakob\eive-software\eive_obsw/linux/devices/SolarArrayDeploymentHandler.h
+11003;DEPL_SA1_GPIO_SWTICH_ON_FAILED;HIGH;;C:\Users\jakob\eive-software\eive_obsw/mission/devices/SolarArrayDeploymentHandler.h
-11004;DEPL_SA2_GPIO_SWTICH_ON_FAILED;HIGH;;C:\Users\jakob\eive-software\eive_obsw/linux/devices/SolarArrayDeploymentHandler.h
+11004;DEPL_SA2_GPIO_SWTICH_ON_FAILED;HIGH;;C:\Users\jakob\eive-software\eive_obsw/mission/devices/SolarArrayDeploymentHandler.h
 11101;MEMORY_READ_RPT_CRC_FAILURE;LOW;;C:\Users\jakob\eive-software\eive_obsw/mission/devices/PlocMPSoCHandler.h
 11102;ACK_FAILURE;LOW;;C:\Users\jakob\eive-software\eive_obsw/mission/devices/PlocMPSoCHandler.h
 11103;EXE_FAILURE;LOW;;C:\Users\jakob\eive-software\eive_obsw/mission/devices/PlocMPSoCHandler.h
@ -101,6 +101,7 @@
 11208;INVALID_ERROR_BYTE;LOW;Received invalid error byte. This indicates an error of the communication link between IMTQ and OBC.;C:\Users\jakob\eive-software\eive_obsw/mission/devices/IMTQHandler.h
 11301;ERROR_STATE;HIGH;Reaction wheel signals an error state;C:\Users\jakob\eive-software\eive_obsw/mission/devices/RwHandler.h
 11401;BOOTING_FIRMWARE_FAILED;LOW;Failed to boot firmware;C:\Users\jakob\eive-software\eive_obsw/linux/devices/startracker/StarTrackerHandler.h
 11402;BOOTING_BOOTLOADER_FAILED;LOW;Failed to boot star tracker into bootloader mode;C:\Users\jakob\eive-software\eive_obsw/linux/devices/startracker/StarTrackerHandler.h
 11501;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;C:\Users\jakob\eive-software\eive_obsw/bsp_q7s/devices/PlocSupervisorHandler.h
 11502;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;C:\Users\jakob\eive-software\eive_obsw/bsp_q7s/devices/PlocSupervisorHandler.h
 11503;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report;C:\Users\jakob\eive-software\eive_obsw/bsp_q7s/devices/PlocSupervisorHandler.h
--- a/generators/events/translateEvents.cpp
+++ b/generators/events/translateEvents.cpp
@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 138 translations.
+ * @brief    Auto-generated event translation file. Contains 139 translations.
 * @details
- * Generated on: 2022-02-22 09:46:40
+ * Generated on: 2022-02-27 15:36:42
 */
 #include "translateEvents.h"
@ -108,6 +108,7 @@ const char *SELF_TEST_COIL_CURRENT_FAILURE_STRING = "SELF_TEST_COIL_CURRENT_FAIL
 const char *INVALID_ERROR_BYTE_STRING = "INVALID_ERROR_BYTE";
 const char *ERROR_STATE_STRING = "ERROR_STATE";
 const char *BOOTING_FIRMWARE_FAILED_STRING = "BOOTING_FIRMWARE_FAILED";
 const char *BOOTING_BOOTLOADER_FAILED_STRING = "BOOTING_BOOTLOADER_FAILED";
 const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
 const char *SUPV_ACK_FAILURE_STRING = "SUPV_ACK_FAILURE";
 const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
@ -352,6 +353,8 @@ const char * translateEvents(Event event) {
 		return ERROR_STATE_STRING;
 	case(11401):
 		return BOOTING_FIRMWARE_FAILED_STRING;
 	case(11402):
 		return BOOTING_BOOTLOADER_FAILED_STRING;
 	case(11501):
 		return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
 	case(11502):
--- a/generators/objects/translateObjects.cpp
+++ b/generators/objects/translateObjects.cpp
@ -2,7 +2,7 @@
 * @brief	Auto-generated object translation file.
 * @details
 * Contains 112 translations.
- * Generated on: 2022-02-25 14:35:18
+ * Generated on: 2022-02-27 15:36:48
 */
 #include "translateObjects.h"
--- a/linux/devices/devicedefinitions/StarTrackerDefinitions.h
+++ b/linux/devices/devicedefinitions/StarTrackerDefinitions.h
@ -122,83 +122,7 @@ enum PoolIds : lp_id_t {
  HISTOGRAM_BIND6,
  HISTOGRAM_BIND7,
  HISTOGRAM_BIND8,
  TICKS_CONTRAST_SET,
  TIME_CONTRAST_SET,
  CONTRAST_BINA0,
  CONTRAST_BINA1,
  CONTRAST_BINA2,
  CONTRAST_BINA3,
  CONTRAST_BINA4,
  CONTRAST_BINA5,
  CONTRAST_BINA6,
  CONTRAST_BINA7,
  CONTRAST_BINA8,
  CONTRAST_BINB0,
  CONTRAST_BINB1,
  CONTRAST_BINB2,
  CONTRAST_BINB3,
  CONTRAST_BINB4,
  CONTRAST_BINB5,
  CONTRAST_BINB6,
  CONTRAST_BINB7,
  CONTRAST_BINB8,
  CONTRAST_BINC0,
  CONTRAST_BINC1,
  CONTRAST_BINC2,
  CONTRAST_BINC3,
  CONTRAST_BINC4,
  CONTRAST_BINC5,
  CONTRAST_BINC6,
  CONTRAST_BINC7,
  CONTRAST_BINC8,
  CONTRAST_BIND0,
  CONTRAST_BIND1,
  CONTRAST_BIND2,
  CONTRAST_BIND3,
  CONTRAST_BIND4,
  CONTRAST_BIND5,
  CONTRAST_BIND6,
  CONTRAST_BIND7,
  CONTRAST_BIND8,
  CHKSUM,
  DWL_ID,
  DWL_PIXX,
  DWL_PIXY,
  DWL_X_UNCORRECTED,
  DWL_Y_UNCORRECTED,
  DWL_X_CORRECTED,
  DWL_Y_CORRECTED,
  DWL_MAGNITUDE,
  DWL_CXA,
  DWL_CYA,
  DWL_QUALITY,
  MATCHEDSTR_ID,
  MATCHEDSTR_CAMFPX,
  MATCHEDSTR_CAMFPY,
  MATCHEDSTR_CAMCARTX,
  MATCHEDSTR_CAMCARTY,
  MATCHEDSTR_CAMCARTZ,
  MATCHEDSTR_CAMMAGNITUDE,
  MATCHEDSTR_DBFPX,
  MATCHEDSTR_DBFPY,
  MATCHEDSTR_DBCARTX,
  MATCHEDSTR_DBCARTY,
  MATCHEDSTR_DBCARTZ,
  MATCHEDSTR_DBMAGNITUDE,
  MATCHEDSTR_CATALOGID,
  DBIMAGE_ID,
  DBIMAGE_PIXX,
  DBIMAGE_PIXY,
  DBIMAGE_X,
  DBIMAGE_Y,
  DBIMAGE_MAGNITUDE,
  BLOBPIX_ID,
  BLOBPIX_X,
  BLOBPIX_Y,
  BLOBPIX_TOT_VAL,
  BLOBPIX_IN_USE,
  BLOBPIX_BRIGHT_NEIGHBOURS,
  BLOBPIX_REGION,
  CAMERA_MODE,
  FOCALLENGTH,
  EXPOSURE,
@ -346,21 +270,16 @@ static const DeviceCommandId_t BOOT = 1;
 static const DeviceCommandId_t REQ_VERSION = 2;
 static const DeviceCommandId_t REQ_INTERFACE = 3;
 static const DeviceCommandId_t REQ_TIME = 4;
 static const DeviceCommandId_t ERASE = 5;
 static const DeviceCommandId_t UNLOCK = 6;
 static const DeviceCommandId_t SWITCH_TO_BOOTLOADER_PROGRAM = 7;
 static const DeviceCommandId_t DOWNLOAD_IMAGE = 9;
 static const DeviceCommandId_t UPLOAD_IMAGE = 10;
 static const DeviceCommandId_t REQ_POWER = 11;
 static const DeviceCommandId_t TAKE_IMAGE = 15;
 static const DeviceCommandId_t DOWNLOAD_CENTROID = 16;
 static const DeviceCommandId_t UPLOAD_CENTROID = 17;
 static const DeviceCommandId_t SUBSCRIPTION = 18;
 static const DeviceCommandId_t IMAGE_PROCESSOR = 19;
 static const DeviceCommandId_t REQ_SOLUTION = 24;
 static const DeviceCommandId_t REQ_TEMPERATURE = 25;
 static const DeviceCommandId_t REQ_HISTOGRAM = 28;
 static const DeviceCommandId_t REQ_CONTRAST = 29;
 static const DeviceCommandId_t LIMITS = 40;
 static const DeviceCommandId_t MOUNTING = 41;
 static const DeviceCommandId_t CAMERA = 42;
@ -372,15 +291,10 @@ static const DeviceCommandId_t VALIDATION = 48;
 static const DeviceCommandId_t ALGO = 49;
 static const DeviceCommandId_t CHECKSUM = 50;
 static const DeviceCommandId_t FLASH_READ = 51;
 static const DeviceCommandId_t DOWNLOAD_MATCHED_STAR = 53;
 static const DeviceCommandId_t STOP_IMAGE_LOADER = 55;
-static const DeviceCommandId_t RESET_ERROR = 56;
+static const DeviceCommandId_t CHANGE_IMAGE_DOWNLOAD_FILE = 57;
 static const DeviceCommandId_t CHANGE_DOWNLOAD_FILE = 57;
 static const DeviceCommandId_t SET_JSON_FILE_NAME = 58;
-static const DeviceCommandId_t SET_READ_FILENAME = 59;
+static const DeviceCommandId_t SET_FLASH_READ_FILENAME = 59;
 static const DeviceCommandId_t SET_TIME = 60;
 static const DeviceCommandId_t DOWNLOAD_DBIMAGE = 61;
 static const DeviceCommandId_t DOWNLOAD_BLOBPIXEL = 62;
 static const DeviceCommandId_t REQ_CAMERA = 67;
 static const DeviceCommandId_t REQ_LIMITS = 68;
 static const DeviceCommandId_t REQ_LOG_LEVEL = 69;
@ -410,12 +324,7 @@ static const uint32_t TEMPERATURE_SET_ID = REQ_TEMPERATURE;
 static const uint32_t TIME_SET_ID = REQ_TIME;
 static const uint32_t SOLUTION_SET_ID = REQ_SOLUTION;
 static const uint32_t HISTOGRAM_SET_ID = REQ_HISTOGRAM;
 static const uint32_t CONTRAST_SET_ID = REQ_CONTRAST;
 static const uint32_t CHECKSUM_SET_ID = CHECKSUM;
 static const uint32_t DOWNLOADCENTROID_SET_ID = DOWNLOAD_CENTROID;
 static const uint32_t DOWNLOAD_MATCHED_STAR_SET_ID = DOWNLOAD_MATCHED_STAR;
 static const uint32_t DOWNLOAD_DBIMAGE_SET_ID = DOWNLOAD_DBIMAGE;
 static const uint32_t DOWNLOAD_BLOBPIXEL_SET_ID = DOWNLOAD_BLOBPIXEL;
 static const uint32_t CAMERA_SET_ID = REQ_CAMERA;
 static const uint32_t LIMITS_SET_ID = REQ_LIMITS;
 static const uint32_t LOG_LEVEL_SET_ID = REQ_LOG_LEVEL;
@ -441,12 +350,7 @@ static const uint8_t POWER_SET_ENTRIES = 18;
 static const uint8_t TIME_SET_ENTRIES = 4;
 static const uint8_t SOLUTION_SET_ENTRIES = 23;
 static const uint8_t HISTOGRAM_SET_ENTRIES = 38;
 static const uint8_t CONTRAST_SET_ENTRIES = 38;
 static const uint8_t CHECKSUM_SET_ENTRIES = 1;
 static const uint8_t DOWNLOAD_CENTROID_SET_ENTRIES = 11;
 static const uint8_t DOWNLOAD_MATCHED_STAR_SET_ENTRIES = 14;
 static const uint8_t DOWNLOAD_DBIMAGE_SET_ENTRIES = 6;
 static const uint8_t DOWNLOAD_BLOBPIXEL_SET_ENTRIES = 7;
 static const uint8_t CAMERA_SET_ENTRIES = 24;
 static const uint8_t LIMITS_SET_ENTRIES = 11;
 static const uint8_t LOG_LEVEL_SET_ENTRIES = 16;
@ -491,15 +395,7 @@ static const uint8_t TIME = 1;
 static const uint8_t WRITE = 2;
 static const uint8_t READ = 3;
 static const uint8_t CHECKSUM = 4;
 static const uint8_t ERASE = 5;
 static const uint8_t UNLOCK = 6;
 static const uint8_t TAKE_IMAGE = 15;
 static const uint8_t ERROR_RESET = 12;
 static const uint8_t DOWNLOAD_CENTROID = 16;
 static const uint8_t UPLOAD_CENTROID = 17;
 static const uint8_t DOWNLOAD_MATCHED_STAR = 18;
 static const uint8_t DOWNLOAD_DBIMAGE = 19;
 static const uint8_t DOWNLOAD_BLOBPIXEL = 24;
 static const uint8_t LOG_LEVEL = 3;
 static const uint8_t LOG_SUBSCRIPTION = 19;
 static const uint8_t DEBUG_CAMERA = 20;
@ -929,100 +825,6 @@ class HistogramSet : public StaticLocalDataSet<HISTOGRAM_SET_ENTRIES> {
  }
 };
 /**
 * @brief   Dataset to store the contrast telemetry data
 */
 class ContrastSet : public StaticLocalDataSet<CONTRAST_SET_ENTRIES> {
 public:
  // Size of dataset
  static const size_t SIZE = 156;
  ContrastSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CONTRAST_SET_ID) {}
  ContrastSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, CONTRAST_SET_ID)) {}
  lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_CONTRAST_SET, this);
  lp_var_t<uint64_t> time = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_CONTRAST_SET, this);
  lp_var_t<uint32_t> binA0 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINA0, this);
  lp_var_t<uint32_t> binA1 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINA1, this);
  lp_var_t<uint32_t> binA2 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINA2, this);
  lp_var_t<uint32_t> binA3 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINA3, this);
  lp_var_t<uint32_t> binA4 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINA4, this);
  lp_var_t<uint32_t> binA5 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINA5, this);
  lp_var_t<uint32_t> binA6 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINA6, this);
  lp_var_t<uint32_t> binA7 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINA7, this);
  lp_var_t<uint32_t> binA8 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINA8, this);
  lp_var_t<uint32_t> binb0 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINB0, this);
  lp_var_t<uint32_t> binB1 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINB1, this);
  lp_var_t<uint32_t> binB2 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINB2, this);
  lp_var_t<uint32_t> binB3 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINB3, this);
  lp_var_t<uint32_t> binB4 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINB4, this);
  lp_var_t<uint32_t> binB5 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINB5, this);
  lp_var_t<uint32_t> binB6 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINB6, this);
  lp_var_t<uint32_t> binB7 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINB7, this);
  lp_var_t<uint32_t> binB8 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINB8, this);
  lp_var_t<uint32_t> binC0 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINC0, this);
  lp_var_t<uint32_t> binC1 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINC1, this);
  lp_var_t<uint32_t> binC2 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINC2, this);
  lp_var_t<uint32_t> binC3 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINC3, this);
  lp_var_t<uint32_t> binC4 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINC4, this);
  lp_var_t<uint32_t> binC5 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINC5, this);
  lp_var_t<uint32_t> binC6 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINC6, this);
  lp_var_t<uint32_t> binC7 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINC7, this);
  lp_var_t<uint32_t> binC8 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BINC8, this);
  lp_var_t<uint32_t> binD0 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BIND0, this);
  lp_var_t<uint32_t> binD1 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BIND1, this);
  lp_var_t<uint32_t> binD2 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BIND2, this);
  lp_var_t<uint32_t> binD3 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BIND3, this);
  lp_var_t<uint32_t> binD4 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BIND4, this);
  lp_var_t<uint32_t> binD5 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BIND5, this);
  lp_var_t<uint32_t> binD6 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BIND6, this);
  lp_var_t<uint32_t> binD7 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BIND7, this);
  lp_var_t<uint32_t> binD8 = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_BIND8, this);
  void printSet() {
    PoolReadGuard rg(this);
    sif::info << "ContrastSet::printSet: Ticks: " << this->ticks << std::endl;
    sif::info << "ContrastSet::printSet: Time (time stamp): " << this->time << " us" << std::endl;
    sif::info << "ContrastSet::printSet: BinA0: " << this->binA0 << std::endl;
    sif::info << "ContrastSet::printSet: BinA1: " << this->binA1 << std::endl;
    sif::info << "ContrastSet::printSet: BinA2: " << this->binA2 << std::endl;
    sif::info << "ContrastSet::printSet: BinA3: " << this->binA3 << std::endl;
    sif::info << "ContrastSet::printSet: BinA4: " << this->binA4 << std::endl;
    sif::info << "ContrastSet::printSet: BinA5: " << this->binA5 << std::endl;
    sif::info << "ContrastSet::printSet: BinA6: " << this->binA6 << std::endl;
    sif::info << "ContrastSet::printSet: BinA7: " << this->binA7 << std::endl;
    sif::info << "ContrastSet::printSet: BinA8: " << this->binA8 << std::endl;
    sif::info << "ContrastSet::printSet: BinB0: " << this->binA0 << std::endl;
    sif::info << "ContrastSet::printSet: BinB1: " << this->binB1 << std::endl;
    sif::info << "ContrastSet::printSet: BinB2: " << this->binB2 << std::endl;
    sif::info << "ContrastSet::printSet: BinB3: " << this->binB3 << std::endl;
    sif::info << "ContrastSet::printSet: BinB4: " << this->binB4 << std::endl;
    sif::info << "ContrastSet::printSet: BinB5: " << this->binB5 << std::endl;
    sif::info << "ContrastSet::printSet: BinB6: " << this->binB6 << std::endl;
    sif::info << "ContrastSet::printSet: BinB7: " << this->binB7 << std::endl;
    sif::info << "ContrastSet::printSet: BinB8: " << this->binB8 << std::endl;
    sif::info << "ContrastSet::printSet: BinC0: " << this->binC0 << std::endl;
    sif::info << "ContrastSet::printSet: BinC1: " << this->binC1 << std::endl;
    sif::info << "ContrastSet::printSet: BinC2: " << this->binC2 << std::endl;
    sif::info << "ContrastSet::printSet: BinC3: " << this->binC3 << std::endl;
    sif::info << "ContrastSet::printSet: BinC4: " << this->binC4 << std::endl;
    sif::info << "ContrastSet::printSet: BinC5: " << this->binC5 << std::endl;
    sif::info << "ContrastSet::printSet: BinC6: " << this->binC6 << std::endl;
    sif::info << "ContrastSet::printSet: BinC7: " << this->binC7 << std::endl;
    sif::info << "ContrastSet::printSet: BinC8: " << this->binC8 << std::endl;
    sif::info << "ContrastSet::printSet: BinD0: " << this->binD0 << std::endl;
    sif::info << "ContrastSet::printSet: BinD1: " << this->binD1 << std::endl;
    sif::info << "ContrastSet::printSet: BinD2: " << this->binD2 << std::endl;
    sif::info << "ContrastSet::printSet: BinD3: " << this->binD3 << std::endl;
    sif::info << "ContrastSet::printSet: BinD4: " << this->binD4 << std::endl;
    sif::info << "ContrastSet::printSet: BinD5: " << this->binD5 << std::endl;
    sif::info << "ContrastSet::printSet: BinD6: " << this->binD6 << std::endl;
    sif::info << "ContrastSet::printSet: BinD7: " << this->binD7 << std::endl;
    sif::info << "ContrastSet::printSet: BinD8: " << this->binD8 << std::endl;
  }
 };
 /**
 * @brief   Helper Class to extract information from bytestream.
 */
@ -1083,16 +885,6 @@ class ChecksumReply {
  uint32_t checksum = 0;
 };
 class EraseReply {
 public:
  EraseReply(const uint8_t* datafield) { region = *datafield; }
  uint8_t getRegion() { return region; }
 private:
  uint8_t region = 0;
 };
 class ChecksumSet : public StaticLocalDataSet<CHECKSUM_SET_ENTRIES> {
 public:
  // Size of dataset
@ -1105,185 +897,6 @@ class ChecksumSet : public StaticLocalDataSet<CHECKSUM_SET_ENTRIES> {
  lp_var_t<uint32_t> checksum = lp_var_t<uint32_t>(sid.objectId, PoolIds::CHKSUM, this);
 };
 /**
 * @brief   Dataset to store download centroid response
 */
 class DownloadCentroidSet : public StaticLocalDataSet<DOWNLOAD_CENTROID_SET_ENTRIES> {
 public:
  // Size of dataset
  static const size_t SIZE = 38;
  DownloadCentroidSet(HasLocalDataPoolIF* owner)
      : StaticLocalDataSet(owner, DOWNLOADCENTROID_SET_ID) {}
  DownloadCentroidSet(object_id_t objectId)
      : StaticLocalDataSet(sid_t(objectId, DOWNLOADCENTROID_SET_ID)) {}
  lp_var_t<uint8_t> id = lp_var_t<uint8_t>(sid.objectId, PoolIds::DWL_ID, this);
  lp_var_t<float> pixx = lp_var_t<float>(sid.objectId, PoolIds::DWL_PIXX, this);
  lp_var_t<float> pixy = lp_var_t<float>(sid.objectId, PoolIds::DWL_PIXY, this);
  lp_var_t<float> xUncorrected = lp_var_t<float>(sid.objectId, PoolIds::DWL_X_UNCORRECTED, this);
  lp_var_t<float> yUncorrected = lp_var_t<float>(sid.objectId, PoolIds::DWL_Y_UNCORRECTED, this);
  lp_var_t<float> xCorrected = lp_var_t<float>(sid.objectId, PoolIds::DWL_X_CORRECTED, this);
  lp_var_t<float> yCorrected = lp_var_t<float>(sid.objectId, PoolIds::DWL_Y_CORRECTED, this);
  lp_var_t<uint8_t> magnitude = lp_var_t<uint8_t>(sid.objectId, PoolIds::DWL_MAGNITUDE, this);
  lp_var_t<float> cxa = lp_var_t<float>(sid.objectId, PoolIds::DWL_CXA, this);
  lp_var_t<float> cya = lp_var_t<float>(sid.objectId, PoolIds::DWL_CYA, this);
  lp_var_t<float> quality = lp_var_t<float>(sid.objectId, PoolIds::DWL_QUALITY, this);
  void printSet() {
    PoolReadGuard rg(this);
    sif::info << "DownloadCentroidSet::printSet: id: " << static_cast<unsigned int>(this->id.value)
              << std::endl;
    sif::info << "DownloadCentroidSet::printSet: pixx: " << this->pixx << std::endl;
    sif::info << "DownloadCentroidSet::printSet: pixy: " << this->pixy << std::endl;
    sif::info << "DownloadCentroidSet::printSet: xUncorrected: " << this->xUncorrected << std::endl;
    sif::info << "DownloadCentroidSet::printSet: yUncorrected: " << this->yUncorrected << std::endl;
    sif::info << "DownloadCentroidSet::printSet: xCorrected: " << this->xCorrected << std::endl;
    sif::info << "DownloadCentroidSet::printSet: yCorrected: " << this->yCorrected << std::endl;
    sif::info << "DownloadCentroidSet::printSet: magnitude: " << this->magnitude << std::endl;
    sif::info << "DownloadCentroidSet::printSet: cxa: " << this->cxa << std::endl;
    sif::info << "DownloadCentroidSet::printSet: cya: " << this->cya << std::endl;
    sif::info << "DownloadCentroidSet::printSet: quality: " << this->quality << std::endl;
  }
 };
 namespace UploadCentroidKeys {
 static const char id[] = "id";
 static const char pixx[] = "pixx";
 static const char pixy[] = "pixy";
 static const char x_uncorrected[] = "x_uncorrected";
 static const char y_uncorrected[] = "y_uncorrected";
 static const char x_corrected[] = "x_corrected";
 static const char y_corrected[] = "y_corrected";
 static const char magnitude[] = "magnitude";
 static const char cxa[] = "cxa";
 static const char cya[] = "cya";
 static const char quality[] = "quality";
 };  // namespace UploadCentroidKeys
 /**
 * @brief   Dataset to store matched star information
 */
 class DownloadMatchedStar : public StaticLocalDataSet<DOWNLOAD_MATCHED_STAR_SET_ENTRIES> {
 public:
  // Size of dataset
  static const size_t SIZE = 53;
  DownloadMatchedStar(HasLocalDataPoolIF* owner)
      : StaticLocalDataSet(owner, DOWNLOAD_MATCHED_STAR_SET_ID) {}
  DownloadMatchedStar(object_id_t objectId)
      : StaticLocalDataSet(sid_t(objectId, DOWNLOAD_MATCHED_STAR_SET_ID)) {}
  lp_var_t<uint8_t> id = lp_var_t<uint8_t>(sid.objectId, PoolIds::MATCHEDSTR_ID, this);
  lp_var_t<float> camfpx = lp_var_t<float>(sid.objectId, PoolIds::MATCHEDSTR_CAMFPX, this);
  lp_var_t<float> camfpy = lp_var_t<float>(sid.objectId, PoolIds::MATCHEDSTR_CAMFPY, this);
  lp_var_t<float> camcartx = lp_var_t<float>(sid.objectId, PoolIds::MATCHEDSTR_CAMCARTX, this);
  lp_var_t<float> camcarty = lp_var_t<float>(sid.objectId, PoolIds::MATCHEDSTR_CAMCARTY, this);
  lp_var_t<float> camcartz = lp_var_t<float>(sid.objectId, PoolIds::MATCHEDSTR_CAMCARTZ, this);
  lp_var_t<float> cammagnitude =
      lp_var_t<float>(sid.objectId, PoolIds::MATCHEDSTR_CAMMAGNITUDE, this);
  lp_var_t<float> dbfpx = lp_var_t<float>(sid.objectId, PoolIds::MATCHEDSTR_DBFPX, this);
  lp_var_t<float> dbfpy = lp_var_t<float>(sid.objectId, PoolIds::MATCHEDSTR_DBFPY, this);
  lp_var_t<float> dbcartx = lp_var_t<float>(sid.objectId, PoolIds::MATCHEDSTR_DBCARTX, this);
  lp_var_t<float> dbcarty = lp_var_t<float>(sid.objectId, PoolIds::MATCHEDSTR_DBCARTY, this);
  lp_var_t<float> dbcartz = lp_var_t<float>(sid.objectId, PoolIds::MATCHEDSTR_DBCARTZ, this);
  lp_var_t<float> dbmagnitude =
      lp_var_t<float>(sid.objectId, PoolIds::MATCHEDSTR_DBMAGNITUDE, this);
  lp_var_t<uint32_t> catalogid =
      lp_var_t<uint32_t>(sid.objectId, PoolIds::MATCHEDSTR_CATALOGID, this);
  void printSet() {
    PoolReadGuard rg(this);
    sif::info << "DownloadMatchedStar::printSet: id: " << static_cast<unsigned int>(this->id.value)
              << std::endl;
    sif::info << "DownloadMatchedStar::printSet: camfpx: " << this->camfpx << std::endl;
    sif::info << "DownloadMatchedStar::printSet: camfpy: " << this->camfpy << std::endl;
    sif::info << "DownloadMatchedStar::printSet: camcartx: " << this->camcartx << std::endl;
    sif::info << "DownloadMatchedStar::printSet: camcarty: " << this->camcarty << std::endl;
    sif::info << "DownloadMatchedStar::printSet: camcartz: " << this->camcartz << std::endl;
    sif::info << "DownloadMatchedStar::printSet: cammagnitude: " << this->cammagnitude << std::endl;
    sif::info << "DownloadMatchedStar::printSet: dbfpx: " << this->dbfpx << std::endl;
    sif::info << "DownloadMatchedStar::printSet: dbfpy: " << this->dbfpy << std::endl;
    sif::info << "DownloadMatchedStar::printSet: dbcartx: " << this->dbcartx << std::endl;
    sif::info << "DownloadMatchedStar::printSet: dbcarty: " << this->dbcarty << std::endl;
    sif::info << "DownloadMatchedStar::printSet: dbcartz: " << this->dbcartz << std::endl;
    sif::info << "DownloadMatchedStar::printSet: dbmagnitude: " << this->dbmagnitude << std::endl;
    sif::info << "DownloadMatchedStar::printSet: catalogid: " << this->catalogid << std::endl;
  }
 };
 /**
 * @brief   Dataset to store the response to the DownloadDBImage request
 */
 class DownloadDBImage : public StaticLocalDataSet<DOWNLOAD_DBIMAGE_SET_ENTRIES> {
 public:
  // Size of dataset
  static const size_t SIZE = 21;
  DownloadDBImage(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, DOWNLOAD_DBIMAGE_SET_ID) {}
  DownloadDBImage(object_id_t objectId)
      : StaticLocalDataSet(sid_t(objectId, DOWNLOAD_DBIMAGE_SET_ID)) {}
  lp_var_t<uint8_t> id = lp_var_t<uint8_t>(sid.objectId, PoolIds::DBIMAGE_ID, this);
  lp_var_t<float> pixx = lp_var_t<float>(sid.objectId, PoolIds::DBIMAGE_PIXX, this);
  lp_var_t<float> pixy = lp_var_t<float>(sid.objectId, PoolIds::DBIMAGE_PIXY, this);
  lp_var_t<float> x = lp_var_t<float>(sid.objectId, PoolIds::DBIMAGE_X, this);
  lp_var_t<float> y = lp_var_t<float>(sid.objectId, PoolIds::DBIMAGE_Y, this);
  lp_var_t<float> magnitude = lp_var_t<float>(sid.objectId, PoolIds::DBIMAGE_MAGNITUDE, this);
  void printSet() {
    PoolReadGuard rg(this);
    sif::info << "DownloadDBImage::printSet: id: " << static_cast<unsigned int>(this->id.value)
              << std::endl;
    sif::info << "DownloadDBImage::printSet: pixx: " << this->pixx << std::endl;
    sif::info << "DownloadDBImage::printSet: pixy: " << this->pixy << std::endl;
    sif::info << "DownloadDBImage::printSet: x: " << this->x << std::endl;
    sif::info << "DownloadDBImage::printSet: y: " << this->y << std::endl;
    sif::info << "DownloadDBImage::printSet: magnitude: " << this->magnitude << std::endl;
  }
 };
 /**
 * @brief   Dataset to store the response to the download blob pixel action request
 */
 class DownloadBlobPixel : public StaticLocalDataSet<DOWNLOAD_BLOBPIXEL_SET_ENTRIES> {
 public:
  // Size of dataset
  static const size_t SIZE = 22;
  DownloadBlobPixel(HasLocalDataPoolIF* owner)
      : StaticLocalDataSet(owner, DOWNLOAD_BLOBPIXEL_SET_ID) {}
  DownloadBlobPixel(object_id_t objectId)
      : StaticLocalDataSet(sid_t(objectId, DOWNLOAD_BLOBPIXEL_SET_ENTRIES)) {}
  lp_var_t<uint8_t> id = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOBPIX_ID, this);
  lp_var_t<uint32_t> x = lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOBPIX_X, this);
  lp_var_t<uint32_t> y = lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOBPIX_Y, this);
  lp_var_t<uint32_t> totalValue = lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOBPIX_TOT_VAL, this);
  lp_var_t<uint8_t> inUse = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOBPIX_IN_USE, this);
  lp_var_t<uint32_t> brightNeighbours =
      lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOBPIX_BRIGHT_NEIGHBOURS, this);
  lp_var_t<uint32_t> region = lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOBPIX_REGION, this);
  void printSet() {
    PoolReadGuard rg(this);
    sif::info << "DownloadBlobPixel::printSet: id: " << static_cast<unsigned int>(this->id.value)
              << std::endl;
    sif::info << "DownloadBlobPixel::printSet: x: " << this->x << std::endl;
    sif::info << "DownloadBlobPixel::printSet: y: " << this->y << std::endl;
    sif::info << "DownloadBlobPixel::printSet: totalValue: " << this->totalValue << std::endl;
    sif::info << "DownloadBlobPixel::printSet: inUse: "
              << static_cast<unsigned int>(this->inUse.value) << std::endl;
    sif::info << "DownloadBlobPixel::printSet: brightNeighbours: " << this->brightNeighbours
              << std::endl;
    sif::info << "DownloadBlobPixel::printSet: region: " << this->region << std::endl;
  }
 };
 /**
 * @brief   Will store the camera parameters set in the star tracker which are retrieved with
 *          a get parameter request.
--- a/linux/devices/startracker/StarTrackerHandler.cpp
+++ b/linux/devices/startracker/StarTrackerHandler.cpp
@ -1,8 +1,6 @@
 #include "StarTrackerHandler.h"
 #include <fsfw/globalfunctions/CRC.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <mission/memory/NVMParameterBase.h>
 #include <fstream>
@ -12,12 +10,9 @@ extern "C" {
 #include <thirdparty/arcsec_star_tracker/client/generated/actionreq.h>
 #include <thirdparty/arcsec_star_tracker/client/generated/parameter.h>
 #include <thirdparty/arcsec_star_tracker/client/generated/telemetry.h>
 #include "common/misc.h"
 }
 using json = nlohmann::json;
 StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
                                       StrHelper* strHelper)
    : DeviceHandlerBase(objectId, comIF, comCookie),
@ -28,12 +23,7 @@ StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF,
      timeSet(this),
      solutionSet(this),
      histogramSet(this),
      contrastSet(this),
      checksumSet(this),
      downloadCentroidSet(this),
      downloadMatchedStar(this),
      downloadDbImage(this),
      downloadBlobPixel(this),
      cameraSet(this),
      limitsSet(this),
      loglevelSet(this),
@ -117,10 +107,10 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
    }
    case (startracker::DISABLE_TIMESTAMP_GENERATION):
      strHelper->disableTimestamping();
-      break;
+      return EXECUTION_FINISHED;
    case (startracker::ENABLE_TIMESTAMP_GENERATION):
      strHelper->enableTimestamping();
-      break;
+      return EXECUTION_FINISHED;
    default:
      break;
  }
@ -184,18 +174,18 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
      strHelperExecuting = true;
      return EXECUTION_FINISHED;
    }
-    case (startracker::CHANGE_DOWNLOAD_FILE): {
+    case (startracker::CHANGE_IMAGE_DOWNLOAD_FILE): {
      if (size > MAX_FILE_NAME) {
        return FILENAME_TOO_LONG;
      }
      strHelper->setDownloadImageName(std::string(reinterpret_cast<const char*>(data), size));
      return EXECUTION_FINISHED;
    }
-    case (startracker::SET_READ_FILENAME): {
+    case (startracker::SET_FLASH_READ_FILENAME): {
      if (size > MAX_FILE_NAME) {
        return FILENAME_TOO_LONG;
      }
-      strHelper->setDownloadImageName(std::string(reinterpret_cast<const char*>(data), size));
+      strHelper->setFlashReadFilename(std::string(reinterpret_cast<const char*>(data), size));
      return EXECUTION_FINISHED;
    }
    case (startracker::FIRMWARE_UPDATE): {
@ -272,11 +262,16 @@ ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t* id
  switch (normalState) {
    case NormalState::TEMPERATURE_REQUEST:
      *id = startracker::REQ_TEMPERATURE;
      normalState = NormalState::SOLUTION_REQUEST;
      break;
    case NormalState::SOLUTION_REQUEST:
      *id = startracker::REQ_SOLUTION;
      normalState = NormalState::TEMPERATURE_REQUEST;
      break;
    default:
      sif::debug << "StarTrackerHandler::buildNormalDeviceCommand: Invalid normal step"
                 << std::endl;
-      break;
+      return NOTHING_TO_SEND;
  }
  return buildCommandFromCommand(*id, NULL, 0);
 }
@ -415,7 +410,7 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
      return RETURN_OK;
    }
    case (startracker::SWITCH_TO_BOOTLOADER_PROGRAM): {
-      prepareRebootCommand();
+      prepareSwitchToBootloaderCmd();
      return RETURN_OK;
    }
    case (startracker::TAKE_IMAGE): {
@ -439,14 +434,6 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
      prepareHistogramRequest();
      return RETURN_OK;
    }
    case (startracker::REQ_CONTRAST): {
      prepareContrastRequest();
      return RETURN_OK;
    }
    case (startracker::RESET_ERROR): {
      prepareErrorResetRequest();
      return RETURN_OK;
    }
    case (startracker::LIMITS): {
      Limits limits;
      result = prepareParamCommand(commandData, commandDataLen, limits);
@ -512,42 +499,10 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
      result = prepareParamCommand(commandData, commandDataLen, debugCamera);
      return result;
    }
    case (startracker::ERASE): {
      result = prepareEraseCommand(commandData, commandDataLen);
      return result;
    }
    case (startracker::UNLOCK): {
      result = prepareUnlockCommand(commandData, commandDataLen);
      return result;
    }
    case (startracker::CHECKSUM): {
      result = prepareChecksumCommand(commandData, commandDataLen);
      return result;
    }
    case (startracker::SET_TIME): {
      result = prepareSetTimeCommand(commandData, commandDataLen);
      return result;
    }
    case (startracker::DOWNLOAD_CENTROID): {
      result = prepareDownloadCentroidCommand(commandData, commandDataLen);
      return result;
    }
    case (startracker::UPLOAD_CENTROID): {
      result = prepareUploadCentroidCommand(commandData, commandDataLen);
      return result;
    }
    case (startracker::DOWNLOAD_MATCHED_STAR): {
      result = prepareDownloadMatchedStarCommand(commandData, commandDataLen);
      return result;
    }
    case (startracker::DOWNLOAD_DBIMAGE): {
      result = prepareDownloadDbImageCommand(commandData, commandDataLen);
      return result;
    }
    case (startracker::DOWNLOAD_BLOBPIXEL): {
      result = prepareDownloadBlobPixelCommand(commandData, commandDataLen);
      return result;
    }
    case (startracker::REQ_CAMERA): {
      result = prepareRequestCameraParams();
      return result;
@ -636,8 +591,6 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::REQ_HISTOGRAM, 3, &histogramSet,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::REQ_CONTRAST, 3, &contrastSet,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::LOGLEVEL, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::LOGSUBSCRIPTION, 3, nullptr,
@ -652,8 +605,6 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::CAMERA, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::CAMERA, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::CENTROIDING, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::LISA, 3, nullptr,
@ -668,25 +619,7 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::TAKE_IMAGE, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
-  this->insertInCommandAndReplyMap(startracker::RESET_ERROR, 3, nullptr,
+  this->insertInCommandAndReplyMap(startracker::CHECKSUM, 3, &checksumSet,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::ERASE, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::UNLOCK, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::CHECKSUM, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::SET_TIME, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::DOWNLOAD_CENTROID, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::UPLOAD_CENTROID, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::DOWNLOAD_MATCHED_STAR, 3, &downloadMatchedStar,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::DOWNLOAD_DBIMAGE, 3, &downloadDbImage,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::DOWNLOAD_BLOBPIXEL, 3, &downloadBlobPixel,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::REQ_CAMERA, 3, &cameraSet,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
@ -890,34 +823,7 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
    }
    case (startracker::BOOT):
    case (startracker::TAKE_IMAGE):
    case (startracker::RESET_ERROR):
    case (startracker::UNLOCK):
    case (startracker::SET_TIME):
      break;
    case (startracker::DOWNLOAD_CENTROID): {
      result = handleActionReplySet(downloadCentroidSet, startracker::DownloadCentroidSet::SIZE);
      break;
    }
    case (startracker::DOWNLOAD_MATCHED_STAR): {
      result = handleActionReplySet(downloadMatchedStar, startracker::DownloadMatchedStar::SIZE);
      break;
    }
    case (startracker::DOWNLOAD_DBIMAGE): {
      result = handleActionReplySet(downloadDbImage, startracker::DownloadDBImage::SIZE);
      break;
    }
    case (startracker::DOWNLOAD_BLOBPIXEL): {
      result = handleActionReplySet(downloadBlobPixel, startracker::DownloadBlobPixel::SIZE);
      break;
    }
    case (startracker::UPLOAD_CENTROID): {
      result = handleUploadCentroidReply();
      break;
    }
    case (startracker::ERASE): {
      result = handleEraseReply();
      break;
    }
    case (startracker::CHECKSUM): {
      result = handleChecksumReply();
      break;
@ -953,10 +859,6 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
      result = handleTm(histogramSet, startracker::HistogramSet::SIZE);
      break;
    }
    case (startracker::REQ_CONTRAST): {
      result = handleTm(contrastSet, startracker::ContrastSet::SIZE);
      break;
    }
    case (startracker::SUBSCRIPTION):
    case (startracker::LOGLEVEL):
    case (startracker::LOGSUBSCRIPTION):
@ -1042,11 +944,6 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
 void StarTrackerHandler::setNormalDatapoolEntriesInvalid() {}
 uint32_t StarTrackerHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
  //  if (modeTo == MODE_ON && (submode == SUBMODE_NONE || submode == SUBMODE_BOOTLOADER)) {
  //    return BOOTLOADER_TRANSITION_DELAY;
  //  } else if (modeTo == MODE_ON && submode == SUBMODE_FIRMWARE && modeFrom == MODE_) {
  //    return FIRMWARE_TRANSITION_DELAY;
  //  }
  return DEFAULT_TRANSITION_DELAY;
 }
@ -1164,82 +1061,6 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
  localDataPoolMap.emplace(startracker::HISTOGRAM_BIND7, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::HISTOGRAM_BIND8, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::TICKS_CONTRAST_SET, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::TIME_CONTRAST_SET, new PoolEntry<uint64_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINA0, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINA1, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINA2, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINA3, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINA4, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINA5, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINA6, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINA7, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINA8, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINB0, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINB1, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINB2, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINB3, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINB4, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINB5, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINB6, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINB7, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINB8, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINC8, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINC0, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINC1, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINC2, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINC3, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINC4, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINC5, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINC6, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINC7, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BINC8, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BIND0, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BIND1, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BIND2, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BIND3, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BIND4, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BIND5, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BIND6, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BIND7, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CONTRAST_BIND8, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CHKSUM, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::DWL_ID, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(startracker::DWL_PIXX, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::DWL_PIXY, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::DWL_X_UNCORRECTED, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::DWL_Y_UNCORRECTED, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::DWL_X_CORRECTED, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::DWL_Y_CORRECTED, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::DWL_MAGNITUDE, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(startracker::DWL_CXA, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::DWL_CYA, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::DWL_QUALITY, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_ID, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_CAMFPX, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_CAMFPY, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_CAMCARTX, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_CAMCARTY, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_CAMCARTZ, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_CAMMAGNITUDE, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_DBFPX, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_DBFPY, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_DBCARTX, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_DBCARTY, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_DBCARTZ, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_DBMAGNITUDE, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::MATCHEDSTR_CATALOGID, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::BLOBPIX_ID, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(startracker::BLOBPIX_X, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::BLOBPIX_Y, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::BLOBPIX_TOT_VAL, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::BLOBPIX_IN_USE, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(startracker::BLOBPIX_BRIGHT_NEIGHBOURS, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::BLOBPIX_REGION, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CAMERA_MODE, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(startracker::FOCALLENGTH, new PoolEntry<float>({0}));
  localDataPoolMap.emplace(startracker::EXPOSURE, new PoolEntry<float>({0}));
@ -1384,6 +1205,8 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
  localDataPoolMap.emplace(startracker::DEBUG_CAMERA_TIMING, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::DEBUG_CAMERA_TEST, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(startracker::CHKSUM, new PoolEntry<uint32_t>({0}));
  return RETURN_OK;
 }
@ -1432,46 +1255,10 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t* foundId)
      *foundId = startracker::UPLOAD_IMAGE;
      break;
    }
    case (startracker::ID::ERROR_RESET): {
      *foundId = startracker::RESET_ERROR;
      break;
    }
    case (startracker::ID::ERASE): {
      *foundId = startracker::ERASE;
      break;
    }
    case (startracker::ID::UNLOCK): {
      *foundId = startracker::UNLOCK;
      break;
    }
    case (startracker::ID::CHECKSUM): {
      *foundId = startracker::CHECKSUM;
      break;
    }
    case (startracker::ID::SET_TIME): {
      *foundId = startracker::SET_TIME;
      break;
    }
    case (startracker::ID::DOWNLOAD_CENTROID): {
      *foundId = startracker::DOWNLOAD_CENTROID;
      break;
    }
    case (startracker::ID::UPLOAD_CENTROID): {
      *foundId = startracker::UPLOAD_CENTROID;
      break;
    }
    case (startracker::ID::DOWNLOAD_MATCHED_STAR): {
      *foundId = startracker::DOWNLOAD_MATCHED_STAR;
      break;
    }
    case (startracker::ID::DOWNLOAD_DBIMAGE): {
      *foundId = startracker::DOWNLOAD_DBIMAGE;
      break;
    }
    case (startracker::ID::DOWNLOAD_BLOBPIXEL): {
      *foundId = startracker::DOWNLOAD_BLOBPIXEL;
      break;
    }
    default:
      sif::warning << "StarTrackerHandler::scanForActionReply: Unknown parameter reply id"
                   << std::endl;
@ -1638,10 +1425,6 @@ ReturnValue_t StarTrackerHandler::scanForTmReply(DeviceCommandId_t* foundId) {
      *foundId = startracker::REQ_HISTOGRAM;
      break;
    }
    case (startracker::ID::CONTRAST): {
      *foundId = startracker::REQ_CONTRAST;
      break;
    }
    case (startracker::ID::TIME): {
      *foundId = startracker::REQ_TIME;
      break;
@ -1678,7 +1461,7 @@ void StarTrackerHandler::handleEvent(EventMessage* eventMessage) {
 ReturnValue_t StarTrackerHandler::executeFlashReadCommand(const uint8_t* commandData,
                                                     size_t commandDataLen) {
  ReturnValue_t result = RETURN_OK;
-  if (commandDataLen < ReadCmd::MIN_LENGTH) {
+  if (commandDataLen < FlashReadCmd::MIN_LENGTH) {
    sif::warning << "StarTrackerHandler::executeFlashReadCommand: Command too short" << std::endl;
    return COMMAND_TOO_SHORT;
  }
@ -1716,42 +1499,6 @@ void StarTrackerHandler::prepareBootCommand() {
  rawPacketLen = dataLinkLayer.getEncodedLength();
 }
 ReturnValue_t StarTrackerHandler::prepareEraseCommand(const uint8_t* commandData,
                                                      size_t commandDataLen) {
  ReturnValue_t result = RETURN_OK;
  if (commandDataLen != EraseCmd::LENGTH) {
    return INVALID_LENGTH;
  }
  uint32_t length = 0;
  struct EraseActionRequest req;
  req.region = *commandData;
  arc_pack_erase_action_req(&req, commandBuffer, &length);
  dataLinkLayer.encodeFrame(commandBuffer, length);
  rawPacket = dataLinkLayer.getEncodedFrame();
  rawPacketLen = dataLinkLayer.getEncodedLength();
  eraseCmd.rememberRegion = req.region;
  return result;
 }
 ReturnValue_t StarTrackerHandler::prepareUnlockCommand(const uint8_t* commandData,
                                                       size_t commandDataLen) {
  ReturnValue_t result = RETURN_OK;
  uint32_t length = 0;
  struct UnlockActionRequest req;
  req.region = *commandData;
  size_t size = sizeof(req.code);
  const uint8_t* codePtr = commandData + UnlockCmd::CODE_OFFSET;
  result = SerializeAdapter::deSerialize(&req.code, &codePtr, &size, SerializeIF::Endianness::BIG);
  if (result != RETURN_OK) {
    return result;
  }
  arc_pack_unlock_action_req(&req, commandBuffer, &length);
  dataLinkLayer.encodeFrame(commandBuffer, length);
  rawPacket = dataLinkLayer.getEncodedFrame();
  rawPacketLen = dataLinkLayer.getEncodedLength();
  return result;
 }
 ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandData,
                                                         size_t commandDataLen) {
  struct ChecksumActionRequest req;
@ -1790,140 +1537,6 @@ ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandD
  return result;
 }
 ReturnValue_t StarTrackerHandler::prepareSetTimeCommand(const uint8_t* commandData,
                                                        size_t commandDataLen) {
  ReturnValue_t result = RETURN_OK;
  struct SetTimeActionRequest req;
  if (commandDataLen != SetTimeCmd::LENGTH) {
    sif::warning << "StarTrackerHandler::prepareSetTimeCommand: Invalid length" << std::endl;
    return INVALID_LENGTH;
  }
  size_t size = sizeof(req.unixTime);
  result = SerializeAdapter::deSerialize(&req.unixTime, commandData, &size,
                                         SerializeIF::Endianness::BIG);
  if (result != RETURN_OK) {
    sif::debug << "StarTrackerHandler::prepareSetTimeCommand: Deserialization failed" << std::endl;
    return result;
  }
  uint32_t length = 0;
  arc_pack_settime_action_req(&req, commandBuffer, &length);
  dataLinkLayer.encodeFrame(commandBuffer, length);
  rawPacket = dataLinkLayer.getEncodedFrame();
  rawPacketLen = dataLinkLayer.getEncodedLength();
  return result;
 }
 ReturnValue_t StarTrackerHandler::prepareDownloadCentroidCommand(const uint8_t* commandData,
                                                                 size_t commandDataLen) {
  ReturnValue_t result = RETURN_OK;
  struct DownloadCentroidActionRequest req;
  if (commandDataLen != DownloadCentroidCmd::LENGTH) {
    sif::warning << "StarTrackerHandler::prepareDownloadCentroidCommand: Invalid length"
                 << std::endl;
    return INVALID_LENGTH;
  }
  req.id = *commandData;
  uint32_t length = 0;
  arc_pack_downloadcentroid_action_req(&req, commandBuffer, &length);
  dataLinkLayer.encodeFrame(commandBuffer, length);
  rawPacket = dataLinkLayer.getEncodedFrame();
  rawPacketLen = dataLinkLayer.getEncodedLength();
  return result;
 }
 ReturnValue_t StarTrackerHandler::prepareUploadCentroidCommand(const uint8_t* commandData,
                                                               size_t commandDataLen) {
  if (commandDataLen > MAX_PATH_SIZE) {
    return FILE_PATH_TOO_LONG;
  }
  ReturnValue_t result = RETURN_OK;
  struct UploadCentroidActionRequest req;
  std::string jsonFileName =
      std::string(reinterpret_cast<const char*>(commandData), commandDataLen);
  NVMParameterBase j(jsonFileName);
  result = j.readJsonFile();
  if (result != RETURN_OK) {
    sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: " << jsonFileName
                 << " does not exist" << std::endl;
    return result;
  }
  result = j.getValue(startracker::UploadCentroidKeys::id, &req.id);
  if (result != RETURN_OK) {
    sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
                 << startracker::UploadCentroidKeys::id << " does not exist" << std::endl;
    return result;
  }
  result = j.getValue(startracker::UploadCentroidKeys::pixx, &req.pixx);
  if (result != RETURN_OK) {
    sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
                 << startracker::UploadCentroidKeys::pixx << " does not exist" << std::endl;
    return result;
  }
  result = j.getValue(startracker::UploadCentroidKeys::pixy, &req.pixy);
  if (result != RETURN_OK) {
    sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
                 << startracker::UploadCentroidKeys::pixy << " does not exist" << std::endl;
    return result;
  }
  result = j.getValue(startracker::UploadCentroidKeys::x_uncorrected, &req.x_uncorrected);
  if (result != RETURN_OK) {
    sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
                 << startracker::UploadCentroidKeys::x_uncorrected << " does not exist"
                 << std::endl;
    return result;
  }
  result = j.getValue(startracker::UploadCentroidKeys::y_uncorrected, &req.y_uncorrected);
  if (result != RETURN_OK) {
    sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
                 << startracker::UploadCentroidKeys::y_uncorrected << " does not exist"
                 << std::endl;
    return result;
  }
  result = j.getValue(startracker::UploadCentroidKeys::x_corrected, &req.x_corrected);
  if (result != RETURN_OK) {
    sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
                 << startracker::UploadCentroidKeys::x_corrected << " does not exist" << std::endl;
    return result;
  }
  result = j.getValue(startracker::UploadCentroidKeys::y_corrected, &req.y_corrected);
  if (result != RETURN_OK) {
    sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
                 << startracker::UploadCentroidKeys::y_corrected << " does not exist" << std::endl;
    return result;
  }
  result = j.getValue(startracker::UploadCentroidKeys::magnitude, &req.magnitude);
  if (result != RETURN_OK) {
    sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
                 << startracker::UploadCentroidKeys::magnitude << " does not exist" << std::endl;
    return result;
  }
  result = j.getValue(startracker::UploadCentroidKeys::cxa, &req.cxa);
  if (result != RETURN_OK) {
    sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
                 << startracker::UploadCentroidKeys::cxa << " does not exist" << std::endl;
    return result;
  }
  result = j.getValue(startracker::UploadCentroidKeys::cya, &req.cya);
  if (result != RETURN_OK) {
    sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
                 << startracker::UploadCentroidKeys::cya << " does not exist" << std::endl;
    return result;
  }
  result = j.getValue(startracker::UploadCentroidKeys::quality, &req.quality);
  if (result != RETURN_OK) {
    sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
                 << startracker::UploadCentroidKeys::quality << " does not exist" << std::endl;
    return result;
  }
  uint32_t length = 0;
  arc_pack_uploadcentroid_action_req(&req, commandBuffer, &length);
  dataLinkLayer.encodeFrame(commandBuffer, length);
  rawPacket = dataLinkLayer.getEncodedFrame();
  rawPacketLen = dataLinkLayer.getEncodedLength();
  uploadCentroid.rememberId = req.id;
  return result;
 }
 void StarTrackerHandler::prepareTimeRequest() {
  uint32_t length = 0;
  arc_tm_pack_time_req(commandBuffer, &length);
@ -1965,7 +1578,7 @@ void StarTrackerHandler::preparePowerRequest() {
  rawPacketLen = dataLinkLayer.getEncodedLength();
 }
-void StarTrackerHandler::prepareRebootCommand() {
+void StarTrackerHandler::prepareSwitchToBootloaderCmd() {
  uint32_t length = 0;
  struct RebootActionRequest rebootReq;
  arc_pack_reboot_action_req(&rebootReq, commandBuffer, &length);
@ -2008,23 +1621,6 @@ void StarTrackerHandler::prepareHistogramRequest() {
  rawPacketLen = dataLinkLayer.getEncodedLength();
 }
 void StarTrackerHandler::prepareContrastRequest() {
  uint32_t length = 0;
  arc_tm_pack_contrast_req(commandBuffer, &length);
  dataLinkLayer.encodeFrame(commandBuffer, length);
  rawPacket = dataLinkLayer.getEncodedFrame();
  rawPacketLen = dataLinkLayer.getEncodedLength();
 }
 void StarTrackerHandler::prepareErrorResetRequest() {
  uint32_t length = 0;
  struct ResetErrorSignalActionRequest req;
  arc_pack_reseterrorsignal_action_req(&req, commandBuffer, &length);
  dataLinkLayer.encodeFrame(commandBuffer, length);
  rawPacket = dataLinkLayer.getEncodedFrame();
  rawPacketLen = dataLinkLayer.getEncodedLength();
 }
 ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData,
                                                      size_t commandDataLen,
                                                      ArcsecJsonParamBase& paramSet) {
@ -2044,73 +1640,6 @@ ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData
  return RETURN_OK;
 }
 ReturnValue_t StarTrackerHandler::prepareDownloadMatchedStarCommand(const uint8_t* commandData,
                                                                    size_t commandDataLen) {
  if (commandDataLen != DownloadMatchedStarCmd::LENGTH) {
    return INVALID_LENGTH;
  }
  struct DownloadMatchedStarActionRequest req;
  req.id = *commandData;
  uint32_t length = 0;
  arc_pack_downloadmatchedstar_action_req(&req, commandBuffer, &length);
  dataLinkLayer.encodeFrame(commandBuffer, length);
  rawPacket = dataLinkLayer.getEncodedFrame();
  rawPacketLen = dataLinkLayer.getEncodedLength();
  return RETURN_OK;
 }
 ReturnValue_t StarTrackerHandler::prepareDownloadDbImageCommand(const uint8_t* commandData,
                                                                size_t commandDataLen) {
  if (commandDataLen != DownloadDbImageCmd::LENGTH) {
    return INVALID_LENGTH;
  }
  struct DownloadDBImageActionRequest req;
  req.id = *commandData;
  uint32_t length = 0;
  arc_pack_downloaddbimage_action_req(&req, commandBuffer, &length);
  dataLinkLayer.encodeFrame(commandBuffer, length);
  rawPacket = dataLinkLayer.getEncodedFrame();
  rawPacketLen = dataLinkLayer.getEncodedLength();
  return RETURN_OK;
 }
 ReturnValue_t StarTrackerHandler::prepareDownloadBlobPixelCommand(const uint8_t* commandData,
                                                                  size_t commandDataLen) {
  if (commandDataLen != DownloadBlobPixCmd::LENGTH) {
    return INVALID_LENGTH;
  }
  struct DownloadBlobPixelActionRequest req;
  req.id = *commandData;
  req.type = *(commandData + 1);
  if ((req.type != DownloadBlobPixCmd::NORMAL) && (req.type != DownloadBlobPixCmd::FAST)) {
    return INVALID_TYPE;
  }
  uint32_t length = 0;
  arc_pack_downloadblobpixel_action_req(&req, commandBuffer, &length);
  dataLinkLayer.encodeFrame(commandBuffer, length);
  rawPacket = dataLinkLayer.getEncodedFrame();
  rawPacketLen = dataLinkLayer.getEncodedLength();
  return RETURN_OK;
 }
 ReturnValue_t StarTrackerHandler::prepareFpgaActionCommand(const uint8_t* commandData,
                                                           size_t commandDataLen) {
  if (commandDataLen != FpgaActionCmd::LENGTH) {
    return INVALID_LENGTH;
  }
  struct FPGAActionActionRequest req;
  req.id = *commandData;
  if (req.id != FpgaActionCmd::ID) {
    return INVALID_ID;
  }
  uint32_t length = 0;
  arc_pack_fpgaaction_action_req(&req, commandBuffer, &length);
  dataLinkLayer.encodeFrame(commandBuffer, length);
  rawPacket = dataLinkLayer.getEncodedFrame();
  rawPacketLen = dataLinkLayer.getEncodedLength();
  return RETURN_OK;
 }
 ReturnValue_t StarTrackerHandler::prepareRequestCameraParams() {
  uint32_t length = 0;
  arc_pack_camera_parameter_req(commandBuffer, &length);
@ -2268,34 +1797,6 @@ ReturnValue_t StarTrackerHandler::handleActionReply() {
  return RETURN_OK;
 }
 ReturnValue_t StarTrackerHandler::handleUploadCentroidReply() {
  ReturnValue_t result = RETURN_OK;
  result = handleActionReply();
  if (result != RETURN_OK) {
    return result;
  }
  const uint8_t* reply = dataLinkLayer.getReply();
  if (*(reply + ACTION_DATA_OFFSET) != uploadCentroid.rememberId) {
    return UPLOAD_CENTROID_ID_MISMATCH;
  }
  return RETURN_OK;
 }
 ReturnValue_t StarTrackerHandler::handleEraseReply() {
  ReturnValue_t result = RETURN_OK;
  result = handleActionReply();
  if (result != RETURN_OK) {
    return result;
  }
  const uint8_t* replyData = dataLinkLayer.getReply() + ACTION_DATA_OFFSET;
  startracker::EraseReply eraseReply(replyData);
  if (eraseReply.getRegion() != eraseCmd.rememberRegion) {
    sif::warning << "StarTrackerHandler::handleEraseReply: Region mismatch" << std::endl;
    return REGION_MISMATCH;
  }
  return result;
 }
 ReturnValue_t StarTrackerHandler::handleChecksumReply() {
  ReturnValue_t result = RETURN_OK;
  result = handleActionReply();
@ -2538,21 +2039,30 @@ ReturnValue_t StarTrackerHandler::checkCommand(ActionId_t actionId) {
    case startracker::UPLOAD_IMAGE:
    case startracker::REQ_POWER:
    case startracker::TAKE_IMAGE:
    case startracker::DOWNLOAD_CENTROID:
    case startracker::UPLOAD_CENTROID:
    case startracker::REQ_SOLUTION:
    case startracker::REQ_TEMPERATURE:
    case startracker::REQ_HISTOGRAM:
-    case startracker::REQ_CONTRAST:
+    case startracker::REQ_CAMERA:
-    case startracker::DOWNLOAD_MATCHED_STAR:
+    case startracker::REQ_LIMITS:
-    case startracker::DOWNLOAD_DBIMAGE:
+    case startracker::REQ_LOG_LEVEL:
-    case startracker::DOWNLOAD_BLOBPIXEL:
+    case startracker::REQ_MOUNTING:
-      if (!(mode == MODE_ON && submode == startracker::Program::FIRMWARE)) {
+    case startracker::REQ_IMAGE_PROCESSOR:
    case startracker::REQ_CENTROIDING:
    case startracker::REQ_LISA:
    case startracker::REQ_MATCHING:
    case startracker::REQ_TRACKING:
    case startracker::REQ_VALIDATION:
    case startracker::REQ_ALGO:
    case startracker::REQ_SUBSCRIPTION:
    case startracker::REQ_LOG_SUBSCRIPTION:
    case startracker::REQ_DEBUG_CAMERA:
      if (not (mode == MODE_ON && submode == startracker::Program::FIRMWARE)) {
        return STARTRACKER_RUNNING_BOOTLOADER;
      }
      break;
    case startracker::FIRMWARE_UPDATE:
-      if (!(mode == MODE_ON && submode == startracker::Program::BOOTLOADER)) {
+    case startracker::FLASH_READ:
      if (not (mode == MODE_ON && submode == startracker::Program::BOOTLOADER)) {
        return STARTRACKER_RUNNING_FIRMWARE;
      }
      break;
--- a/linux/devices/startracker/StarTrackerHandler.h
+++ b/linux/devices/startracker/StarTrackerHandler.h
@ -85,65 +85,53 @@ class StarTrackerHandler : public DeviceHandlerBase {
  //! [EXPORT] : [COMMENT] Ping command failed
  static const ReturnValue_t PING_FAILED = MAKE_RETURN_CODE(0xA1);
  //! [EXPORT] : [COMMENT] Status in version reply signals error
-  static const ReturnValue_t VERSION_REQ_FAILED = MAKE_RETURN_CODE(0xA3);
+  static const ReturnValue_t VERSION_REQ_FAILED = MAKE_RETURN_CODE(0xA2);
  //! [EXPORT] : [COMMENT] Status in interface reply signals error
-  static const ReturnValue_t INTERFACE_REQ_FAILED = MAKE_RETURN_CODE(0xA4);
+  static const ReturnValue_t INTERFACE_REQ_FAILED = MAKE_RETURN_CODE(0xA3);
  //! [EXPORT] : [COMMENT] Status in power reply signals error
-  static const ReturnValue_t POWER_REQ_FAILED = MAKE_RETURN_CODE(0xA5);
+  static const ReturnValue_t POWER_REQ_FAILED = MAKE_RETURN_CODE(0xA4);
  //! [EXPORT] : [COMMENT] Status of reply to parameter set command signals error
-  static const ReturnValue_t SET_PARAM_FAILED = MAKE_RETURN_CODE(0xA6);
+  static const ReturnValue_t SET_PARAM_FAILED = MAKE_RETURN_CODE(0xA5);
  //! [EXPORT] : [COMMENT] Status of reply to action command signals error
-  static const ReturnValue_t ACTION_FAILED = MAKE_RETURN_CODE(0xA7);
+  static const ReturnValue_t ACTION_FAILED = MAKE_RETURN_CODE(0xA6);
  //! [EXPORT] : [COMMENT] Received upload image command with invalid length
  static const ReturnValue_t UPLOAD_TOO_SHORT = MAKE_RETURN_CODE(0xA8);
  //! [EXPORT] : [COMMENT] Received upload image command with invalid position field
  static const ReturnValue_t UPLOAD_INVALID_POSITION = MAKE_RETURN_CODE(0xA8);
  //! [EXPORT] : [COMMENT] Position value in upload image reply not matching sent position
  static const ReturnValue_t UPLOAD_IMAGE_FAILED = MAKE_RETURN_CODE(0xA9);
  //! [EXPORT] : [COMMENT] Received upload image command with invalid length
  static const ReturnValue_t INVALID_UPLOAD_COMMAND = MAKE_RETURN_CODE(0xAA);
  //! [EXPORT] : [COMMENT] Received invalid path string. Exceeds allowed length
-  static const ReturnValue_t FILE_PATH_TOO_LONG = MAKE_RETURN_CODE(0xAB);
+  static const ReturnValue_t FILE_PATH_TOO_LONG = MAKE_RETURN_CODE(0xA7);
  //! [EXPORT] : [COMMENT] Name of file received with command is too long
-  static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xAC);
+  static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA8);
  //! [EXPORT] : [COMMENT] Received version reply with invalid program ID
-  static const ReturnValue_t INVALID_PROGRAM = MAKE_RETURN_CODE(0xAD);
+  static const ReturnValue_t INVALID_PROGRAM = MAKE_RETURN_CODE(0xA9);
  //! [EXPORT] : [COMMENT] Status field reply signals error
-  static const ReturnValue_t REPLY_ERROR = MAKE_RETURN_CODE(0xAE);
+  static const ReturnValue_t REPLY_ERROR = MAKE_RETURN_CODE(0xAA);
  //! [EXPORT] : [COMMENT] Status field of contrast reply signals error
  static const ReturnValue_t CONTRAST_REQ_FAILED = MAKE_RETURN_CODE(0xAE);
  //! [EXPORT] : [COMMENT] Received command which is too short (some data is missing for proper
  //! execution)
-  static const ReturnValue_t COMMAND_TOO_SHORT = MAKE_RETURN_CODE(0xAF);
+  static const ReturnValue_t COMMAND_TOO_SHORT = MAKE_RETURN_CODE(0xAB);
  //! [EXPORT] : [COMMENT] Received command with invalid length (too few or too many parameters)
-  static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xB0);
+  static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xAC);
  //! [EXPORT] : [COMMENT] Region mismatch between send and received data
-  static const ReturnValue_t REGION_MISMATCH = MAKE_RETURN_CODE(0xB1);
+  static const ReturnValue_t REGION_MISMATCH = MAKE_RETURN_CODE(0xAD);
  //! [EXPORT] : [COMMENT] Address mismatch between send and received data
-  static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(0xB2);
+  static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(0xAE);
  //! [EXPORT] : [COMMENT] Length field mismatch between send and received data
-  static const ReturnValue_t lENGTH_MISMATCH = MAKE_RETURN_CODE(0xB3);
+  static const ReturnValue_t lENGTH_MISMATCH = MAKE_RETURN_CODE(0xAF);
  //! [EXPORT] : [COMMENT] Specified file does not exist
-  static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xB4);
+  static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xB0);
  //! [EXPORT] : [COMMENT] Reply to upload centroid does not match commanded centroid id
  static const ReturnValue_t UPLOAD_CENTROID_ID_MISMATCH = MAKE_RETURN_CODE(0xB5);
  //! [EXPORT] : [COMMENT] Download blob pixel command has invalid type field
-  static const ReturnValue_t INVALID_TYPE = MAKE_RETURN_CODE(0xB6);
+  static const ReturnValue_t INVALID_TYPE = MAKE_RETURN_CODE(0xB1);
  //! [EXPORT] : [COMMENT] Received FPGA action command with invalid ID
-  static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xB7);
+  static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xB2);
  //! [EXPORT] : [COMMENT] Received reply is too short
-  static const ReturnValue_t REPLY_TOO_SHORT = MAKE_RETURN_CODE(0xB8);
+  static const ReturnValue_t REPLY_TOO_SHORT = MAKE_RETURN_CODE(0xB3);
  //! [EXPORT] : [COMMENT] Received reply with invalid CRC
-  static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xB9);
+  static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xB4);
  //! [EXPORT] : [COMMENT] Star tracker handler currently executing a command and using the
  //! communication interface
-  static const ReturnValue_t STR_HELPER_EXECUTING = MAKE_RETURN_CODE(0xBA);
+  static const ReturnValue_t STR_HELPER_EXECUTING = MAKE_RETURN_CODE(0xB5);
  //! [EXPORT] : [COMMENT] Star tracker is already in firmware mode
-  static const ReturnValue_t STARTRACKER_ALREADY_BOOTED = MAKE_RETURN_CODE(0xBB);
+  static const ReturnValue_t STARTRACKER_ALREADY_BOOTED = MAKE_RETURN_CODE(0xB6);
  //! [EXPORT] : [COMMENT] Star tracker is in firmware mode but must be in bootloader mode to execute this command
-  static const ReturnValue_t STARTRACKER_RUNNING_FIRMWARE = MAKE_RETURN_CODE(0xBC);
+  static const ReturnValue_t STARTRACKER_RUNNING_FIRMWARE = MAKE_RETURN_CODE(0xB7);
  //! [EXPORT] : [COMMENT] Star tracker is in bootloader mode but must be in firmware mode to execute this command
-  static const ReturnValue_t STARTRACKER_RUNNING_BOOTLOADER = MAKE_RETURN_CODE(0xBD);
+  static const ReturnValue_t STARTRACKER_RUNNING_BOOTLOADER = MAKE_RETURN_CODE(0xB8);
  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::STR_HANDLER;
@ -155,10 +143,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
  static const size_t MAX_PATH_SIZE = 50;
  static const size_t MAX_FILE_NAME = 30;
  // position (uint32) + 1024 image data
  static const size_t UPLOAD_COMMAND_LEN = 1028;
  // Max valid position value in upload image command
  static const uint16_t MAX_POSITION = 4095;
  static const uint8_t STATUS_OFFSET = 1;
  static const uint8_t PARAMS_OFFSET = 1;
  static const uint8_t TICKS_OFFSET = 2;
@ -175,33 +159,12 @@ class StarTrackerHandler : public DeviceHandlerBase {
  static const uint32_t BOOT_TIMEOUT = 1000;
  static const uint32_t DEFAULT_TRANSITION_DELAY = 15000;
-  class WriteCmd {
+  class FlashReadCmd {
   public:
    static const uint8_t ADDRESS_OFFSET = 1;
    static const uint8_t FILE_OFFSET = 5;
    // Minimum length of a write command (region, address and filename)
    static const size_t MIN_LENGTH = 7;
  };
  class ReadCmd {
   public:
    // Minimum length of a read command (region, length and filename)
    static const size_t MIN_LENGTH = 7;
  };
  class EraseCmd {
   public:
    static const uint8_t LENGTH = 1;
    uint8_t rememberRegion = 0;
  };
  EraseCmd eraseCmd;
  class UnlockCmd {
   public:
    static const uint8_t CODE_OFFSET = 1;
  };
  class ChecksumCmd {
   public:
    static const uint8_t ADDRESS_OFFSET = 1;
@ -215,51 +178,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
  ChecksumCmd checksumCmd;
  class SetTimeCmd {
   public:
    static const uint8_t LENGTH = 8;
  };
  class DownloadCentroidCmd {
   public:
    static const uint8_t LENGTH = 1;
  };
  class UploadCentroid {
   public:
    uint8_t rememberId = 0;
  };
  UploadCentroid uploadCentroid;
  class DownloadMatchedStarCmd {
   public:
    static const uint8_t LENGTH = 1;
  };
  class DownloadDbImageCmd {
   public:
    static const uint8_t LENGTH = 1;
  };
  class DownloadBlobPixCmd {
   public:
    static const uint8_t LENGTH = 2;
    static const uint8_t NORMAL = 0;
    static const uint8_t FAST = 1;
  };
  class FpgaDownloadCmd {
   public:
    static const uint8_t MIN_LENGTH = 10;
  };
  class FpgaActionCmd {
   public:
    static const uint8_t LENGTH = 1;
    static const uint8_t ID = 3;
  };
  MessageQueueIF* eventQueue = nullptr;
  ArcsecDatalinkLayer dataLinkLayer;
@ -271,12 +189,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
  startracker::TimeSet timeSet;
  startracker::SolutionSet solutionSet;
  startracker::HistogramSet histogramSet;
  startracker::ContrastSet contrastSet;
  startracker::ChecksumSet checksumSet;
  startracker::DownloadCentroidSet downloadCentroidSet;
  startracker::DownloadMatchedStar downloadMatchedStar;
  startracker::DownloadDBImage downloadDbImage;
  startracker::DownloadBlobPixel downloadBlobPixel;
  startracker::CameraSet cameraSet;
  startracker::LimitsSet limitsSet;
  startracker::LogLevelSet loglevelSet;
@ -312,7 +225,8 @@ class StarTrackerHandler : public DeviceHandlerBase {
 #endif
  enum class NormalState {
-      TEMPERATURE_REQUEST
+      TEMPERATURE_REQUEST,
      SOLUTION_REQUEST
  };
  NormalState normalState = NormalState::TEMPERATURE_REQUEST;
@ -415,36 +329,11 @@ class StarTrackerHandler : public DeviceHandlerBase {
   */
  void prepareBootCommand();
  /**
   * @brief   Fills command buffer with command to erase a flash region
   */
  ReturnValue_t prepareEraseCommand(const uint8_t* commandData, size_t commandDataLen);
  /**
   * @brief   Fills command buffer with command to unlock flash region
   */
  ReturnValue_t prepareUnlockCommand(const uint8_t* commandData, size_t commandDataLen);
  /**
   * @brief   Fills command buffer with command to get the checksum of a flash part
   */
  ReturnValue_t prepareChecksumCommand(const uint8_t* commandData, size_t commandDataLen);
  /**
   * @brief   Fills command buffer with command to set the unix time
   */
  ReturnValue_t prepareSetTimeCommand(const uint8_t* commandData, size_t commandDataLen);
  /**
   * @brief   Fills command buffer with command to request a centroid
   */
  ReturnValue_t prepareDownloadCentroidCommand(const uint8_t* commandData, size_t commandDataLen);
  /**
   * @brief   Fills command buffer with command to upload a centroid for testing purpose
   */
  ReturnValue_t prepareUploadCentroidCommand(const uint8_t* commandData, size_t commandDataLen);
  /**
   * @brief   Fills the command buffer with the command to take an image.
   */
@ -468,7 +357,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
  /**
   * @brief   Fills command buffer with data to reboot star tracker.
   */
-  void prepareRebootCommand();
+  void prepareSwitchToBootloaderCmd();
  /**
   * @brief   Fills command buffer with data to subscribe to a telemetry packet.
@ -493,13 +382,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
   */
  void prepareHistogramRequest();
  void prepareContrastRequest();
  /**
   * @brief   Fills command buffer with command to reset the error signal of the star tracker
   */
  void prepareErrorResetRequest();
  /**
   * @brief   Reads parameters from json file specified by string in commandData and
   *          prepares the command to apply the parameter set to the star tracker
@ -513,27 +395,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
  ReturnValue_t prepareParamCommand(const uint8_t* commandData, size_t commandDataLen,
                                    ArcsecJsonParamBase& paramSet);
  /**
   * @brief   Fills command buffer with data to request matched star.
   */
  ReturnValue_t prepareDownloadMatchedStarCommand(const uint8_t* commandData,
                                                  size_t commandDataLen);
  /**
   * @brief   Fills command buffer with data to request matched star coordinates.
   */
  ReturnValue_t prepareDownloadDbImageCommand(const uint8_t* commandData, size_t commandDataLen);
  /**
   * @brief   Fills command buffer with data to request output of the blob filter algorithm.
   */
  ReturnValue_t prepareDownloadBlobPixelCommand(const uint8_t* commandData, size_t commandDataLen);
  /**
   * @brief   With this command the FPGA update will be applied to the star tracker
   */
  ReturnValue_t prepareFpgaActionCommand(const uint8_t* commandData, size_t commandDataLen);
  /**
   * @brief   The following function will fill the command buffer with the command to request
   *          a parameter set.
@ -568,11 +429,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
   */
  ReturnValue_t handleUploadCentroidReply();
  /**
   * @brief   Handles reply to erase command
   */
  ReturnValue_t handleEraseReply();
  /**
   * @brief   Handles reply to checksum command
   */
--- a/linux/devices/startracker/StrHelper.cpp
+++ b/linux/devices/startracker/StrHelper.cpp
@ -430,6 +430,9 @@ ReturnValue_t StrHelper::performFlashRead() {
        req.region++;
    }
    retries = 0;
 #if OBSW_DEBUG_STARTRACKER == 1
    printProgress(bytesRead, flashRead.size);
 #endif /* OBSW_DEBUG_STARTRACKER == 1 */
  }
  file.close();
  return RETURN_OK;
--- a/linux/fsfwconfig/events/translateEvents.cpp
+++ b/linux/fsfwconfig/events/translateEvents.cpp
@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 138 translations.
+ * @brief    Auto-generated event translation file. Contains 139 translations.
 * @details
- * Generated on: 2022-02-22 09:46:40
+ * Generated on: 2022-02-27 15:36:42
 */
 #include "translateEvents.h"
@ -108,6 +108,7 @@ const char *SELF_TEST_COIL_CURRENT_FAILURE_STRING = "SELF_TEST_COIL_CURRENT_FAIL
 const char *INVALID_ERROR_BYTE_STRING = "INVALID_ERROR_BYTE";
 const char *ERROR_STATE_STRING = "ERROR_STATE";
 const char *BOOTING_FIRMWARE_FAILED_STRING = "BOOTING_FIRMWARE_FAILED";
 const char *BOOTING_BOOTLOADER_FAILED_STRING = "BOOTING_BOOTLOADER_FAILED";
 const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
 const char *SUPV_ACK_FAILURE_STRING = "SUPV_ACK_FAILURE";
 const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
@ -352,6 +353,8 @@ const char * translateEvents(Event event) {
 		return ERROR_STATE_STRING;
 	case(11401):
 		return BOOTING_FIRMWARE_FAILED_STRING;
 	case(11402):
 		return BOOTING_BOOTLOADER_FAILED_STRING;
 	case(11501):
 		return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
 	case(11502):
--- a/linux/fsfwconfig/objects/translateObjects.cpp
+++ b/linux/fsfwconfig/objects/translateObjects.cpp
@ -2,7 +2,7 @@
 * @brief	Auto-generated object translation file.
 * @details
 * Contains 112 translations.
- * Generated on: 2022-02-25 14:35:18
+ * Generated on: 2022-02-27 15:36:48
 */
 #include "translateObjects.h"
--- a/scripts/egse-port.sh
+++ b/scripts/egse-port.sh
@ -1,6 +1,6 @@
 #!/bin/bash
-echo "-L 1534:localhost:1534 portforwarding for tcf agent"
+echo "-L 1534:localhost:1534 pi@192.168.18.31 portforwarding for tcf agent"
-echo "-L 1537:localhost:7301 for TMTC commanding using the TCP/IP IF"
+echo "-L 1537:localhost:7301 pi@192.168.18.31 for TMTC commanding using the TCP/IP IF"
 ssh -L 1534:localhost:1534 \
 		-L 1537:localhost:7301 pi@192.168.18.31
		`@ -1 +1 @@`
			`Subproject commit 09c1918c1fe36a07ce611a33ff20799187d8d962`				`Subproject commit eacb4ac4079ff2bf5e0648626332e59046a409da`