diff --git a/bsp_q7s/devices/startracker/ArcsecJsonKeys.h b/bsp_q7s/devices/startracker/ArcsecJsonKeys.h
index 58520968..2c598b43 100644
--- a/bsp_q7s/devices/startracker/ArcsecJsonKeys.h
+++ b/bsp_q7s/devices/startracker/ArcsecJsonKeys.h
@@ -71,11 +71,56 @@ namespace arcseckeys {
     static const char ENABLE_CONTRAST[] = "enableContrast";
     static const char BIN_MODE[] = "binMode";
 
+    static const char CENTROIDING[] = "centroiding";
+    static const char ENABLE_FILTER[] = "enableFilter";
+    static const char MAX_QUALITY[] = "maxquality";
+    static const char MIN_QUALITY[] = "minquality";
+    static const char MAX_INTENSITY[] = "maxintensity";
+    static const char MIN_INTENSITY[] = "minintensity";
+    static const char MAX_MAGNITUDE[] = "maxmagnitude";
+    static const char GAUSSIAN_CMAX[] = "gaussianCmax";
+    static const char GAUSSIAN_CMIN[] = "gaussianCmin";
+    static const char TRANSMATRIX_00[] = "transmatrix00";
+    static const char TRANSMATRIX_01[] = "transmatrix01";
+    static const char TRANSMATRIX_10[] = "transmatrix10";
+    static const char TRANSMATRIX_11[] = "transmatrix11";
+
+    static const char LISA[] = "lisa";
+    static const char PREFILTER_DIST_THRESHOLD[] = "prefilterDistThreshold";
+    static const char PREFILTER_ANGLE_THRESHOLD[] = "prefilterAngleThreshold";
+    static const char FOV_WIDTH[] = "fov_width";
+    static const char FOV_HEIGHT[] = "fov_height";
+    static const char FLOAT_STAR_LIMIT[] = "float_star_limit";
+    static const char CLOSE_STAR_LIMIT[] = "close_star_limit";
+    static const char RATING_WEIGHT_CLOSE_STAR_COUNT[] = "rating_weight_close_star_count";
+    static const char RATING_WEIGHT_FRACTION_CLOSE[] = "rating_weight_fraction_close";
+    static const char RATING_WEIGHT_MEAN_SUM[] = "rating_weight_mean_sum";
+    static const char RATING_WEIGHT_DB_STAR_COUNT[] = "rating_weight_db_star_count";
+    static const char MAX_COMBINATIONS[] = "max_combinations";
+    static const char NR_STARS_STOP[] = "nr_stars_stop";
+    static const char FRACTION_CLOSE_STOP[] = "fraction_close_stop";
+
+    static const char MATCHING[] = "matching";
+    static const char SQUARED_DISTANCE_LIMIT[] = "squaredDistanceLimit";
+    static const char SQUARED_SHIFT_LIMIT[] = "squaredShiftLimit";
+
+    static const char VALIDATION[] = "validation";
+    static const char STABLE_COUNT[] = "stable_count";
+    static const char MAX_DIFFERENCE[] = "max_difference";
+    static const char MIN_TRACKER_CONFIDENCE[] = "min_trackerConfidence";
+    static const char MIN_MATCHED_STARS[] = "min_matchedStars";
+
     static const char TRACKING[] = "tracking";
     static const char THIN_LIMIT[] = "thinLimit";
     static const char OUTLIER_THRESHOLD[] = "outlierThreshold";
     static const char OUTLIER_THRESHOLD_QUEST[] = "outlierThresholdQUEST";
     static const char TRACKER_CHOICE[] = "trackerChoice";
+
+    static const char ALGO[] = "algo";
+    static const char L2T_MIN_CONFIDENCE[] = "l2t_minConfidence";
+    static const char L2T_MIN_MATCHED[] = "l2t_minConfidence";
+    static const char T2L_MIN_CONFIDENCE[] = "t2l_minConfidence";
+    static const char T2L_MIN_MATCHED[] = "t2l_minMatched";
 }
 
 #endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_ARCSECJSONKEYS_H_ */
diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp
index 088bd798..d0a926a0 100644
--- a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp
+++ b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp
@@ -213,6 +213,31 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
         result = prepareParamCommand(commandData, commandDataLen, blob);
         return result;
     }
+    case (StarTracker::CENTROIDING): {
+        Centroiding centroiding;
+        result = prepareParamCommand(commandData, commandDataLen, centroiding);
+        return result;
+    }
+    case (StarTracker::LISA): {
+        Lisa lisa;
+        result = prepareParamCommand(commandData, commandDataLen, lisa);
+        return result;
+    }
+    case (StarTracker::MATCHING): {
+        Matching matching;
+        result = prepareParamCommand(commandData, commandDataLen, matching);
+        return result;
+    }
+    case (StarTracker::VALIDATION): {
+        Validation validation;
+        result = prepareParamCommand(commandData, commandDataLen, validation);
+        return result;
+    }
+    case (StarTracker::ALGO): {
+        Algo algo;
+        result = prepareParamCommand(commandData, commandDataLen, algo);
+        return result;
+    }
     case (StarTracker::TRACKING): {
         Tracking tracking;
         result = prepareParamCommand(commandData, commandDataLen, tracking);
diff --git a/bsp_q7s/devices/startracker/StarTrackerJsonCommands.cpp b/bsp_q7s/devices/startracker/StarTrackerJsonCommands.cpp
index dd91eddf..2c7bbf1d 100644
--- a/bsp_q7s/devices/startracker/StarTrackerJsonCommands.cpp
+++ b/bsp_q7s/devices/startracker/StarTrackerJsonCommands.cpp
@@ -324,6 +324,7 @@ ReturnValue_t Camera::createCommand(uint8_t* buffer) {
     return RETURN_OK;
 }
 
+
 Blob::Blob() : ArcsecJsonParamBase(arcseckeys::BLOB) {}
 
 size_t Blob::getSize() {
@@ -429,7 +430,8 @@ ReturnValue_t Blob::createCommand(uint8_t* buffer) {
     return RETURN_OK;
 }
 
-Centroiding::Centroiding() : ArcsecJsonParamBase(arcseckeys::BLOB) {}
+
+Centroiding::Centroiding() : ArcsecJsonParamBase(arcseckeys::CENTROIDING) {}
 
 size_t Centroiding::getSize() {
     return COMMAND_SIZE;
@@ -439,7 +441,247 @@ ReturnValue_t Centroiding::createCommand(uint8_t* buffer) {
     ReturnValue_t result = RETURN_OK;
     uint8_t offset = 0;
     std::string param;
-    addSetParamHeader(buffer, StarTracker::ID::BLOB);
+    addSetParamHeader(buffer, StarTracker::ID::CENTROIDING);
+    offset = 2;
+    result = getParam(arcseckeys::ENABLE_FILTER, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    adduint8(param, buffer + offset);
+    offset += sizeof(uint8_t);
+    result = getParam(arcseckeys::MAX_QUALITY, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::MIN_QUALITY, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::MAX_INTENSITY, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::MIN_INTENSITY, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::MAX_MAGNITUDE, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::GAUSSIAN_CMAX, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::GAUSSIAN_CMIN, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::TRANSMATRIX_00, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::TRANSMATRIX_01, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::TRANSMATRIX_10, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::TRANSMATRIX_11, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    return RETURN_OK;
+}
+
+
+Lisa::Lisa() : ArcsecJsonParamBase(arcseckeys::LISA) {}
+
+size_t Lisa::getSize() {
+    return COMMAND_SIZE;
+}
+
+ReturnValue_t Lisa::createCommand(uint8_t* buffer) {
+    ReturnValue_t result = RETURN_OK;
+    uint8_t offset = 0;
+    std::string param;
+    addSetParamHeader(buffer, StarTracker::ID::LISA);
+    offset = 2;
+    result = getParam(arcseckeys::PREFILTER_DIST_THRESHOLD, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::PREFILTER_ANGLE_THRESHOLD, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::FOV_WIDTH, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::FOV_HEIGHT, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::FLOAT_STAR_LIMIT, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::CLOSE_STAR_LIMIT, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::RATING_WEIGHT_CLOSE_STAR_COUNT, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::RATING_WEIGHT_FRACTION_CLOSE, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::RATING_WEIGHT_DB_STAR_COUNT, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::MAX_COMBINATIONS, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    adduint8(param, buffer + offset);
+    offset += sizeof(uint8_t);
+    result = getParam(arcseckeys::NR_STARS_STOP, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    adduint8(param, buffer + offset);
+    offset += sizeof(uint8_t);
+    result = getParam(arcseckeys::FRACTION_CLOSE_STOP, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    return RETURN_OK;
+}
+
+
+Matching::Matching() : ArcsecJsonParamBase(arcseckeys::MATCHING) {}
+
+size_t Matching::getSize() {
+    return COMMAND_SIZE;
+}
+
+ReturnValue_t Matching::createCommand(uint8_t* buffer) {
+    ReturnValue_t result = RETURN_OK;
+    uint8_t offset = 0;
+    std::string param;
+    addSetParamHeader(buffer, StarTracker::ID::MATCHING);
+    offset = 2;
+    result = getParam(arcseckeys::SQUARED_DISTANCE_LIMIT, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::SQUARED_SHIFT_LIMIT, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    return RETURN_OK;
+}
+
+
+Validation::Validation() : ArcsecJsonParamBase(arcseckeys::VALIDATION) {}
+
+size_t Validation::getSize() {
+    return COMMAND_SIZE;
+}
+
+ReturnValue_t Validation::createCommand(uint8_t* buffer) {
+    ReturnValue_t result = RETURN_OK;
+    uint8_t offset = 0;
+    std::string param;
+    addSetParamHeader(buffer, StarTracker::ID::MATCHING);
+    offset = 2;
+    result = getParam(arcseckeys::STABLE_COUNT, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    adduint8(param, buffer + offset);
+    offset += sizeof(uint8_t);
+    result = getParam(arcseckeys::MAX_DIFFERENCE, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::MIN_TRACKER_CONFIDENCE, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::MIN_MATCHED_STARS, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    adduint8(param, buffer + offset);
+    return RETURN_OK;
+}
+
+Algo::Algo() : ArcsecJsonParamBase(arcseckeys::ALGO) {}
+
+size_t Algo::getSize() {
+    return COMMAND_SIZE;
+}
+
+ReturnValue_t Algo::createCommand(uint8_t* buffer) {
+    ReturnValue_t result = RETURN_OK;
+    uint8_t offset = 0;
+    std::string param;
+    addSetParamHeader(buffer, StarTracker::ID::ALGO);
     offset = 2;
     result = getParam(arcseckeys::MODE, param);
     if (result != RETURN_OK) {
@@ -447,89 +689,28 @@ ReturnValue_t Centroiding::createCommand(uint8_t* buffer) {
     }
     adduint8(param, buffer + offset);
     offset += sizeof(uint8_t);
-    result = getParam(arcseckeys::MIN_VALUE, param);
+    result = getParam(arcseckeys::L2T_MIN_CONFIDENCE, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::L2T_MIN_MATCHED, param);
     if (result != RETURN_OK) {
         return result;
     }
     adduint8(param, buffer + offset);
     offset += sizeof(uint8_t);
-    result = getParam(arcseckeys::MIN_DISTANCE, param);
+    result = getParam(arcseckeys::T2L_MIN_CONFIDENCE, param);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    addfloat(param, buffer + offset);
+    offset += sizeof(float);
+    result = getParam(arcseckeys::T2L_MIN_MATCHED, param);
     if (result != RETURN_OK) {
         return result;
     }
     adduint8(param, buffer + offset);
-    offset += sizeof(uint8_t);
-    result = getParam(arcseckeys::NEIGHBOUR_DISTANCE, param);
-    if (result != RETURN_OK) {
-        return result;
-    }
-    adduint8(param, buffer + offset);
-    offset += sizeof(uint8_t);
-    result = getParam(arcseckeys::NEIGHBOUR_BRIGHT_PIXELS, param);
-    if (result != RETURN_OK) {
-        return result;
-    }
-    adduint8(param, buffer + offset);
-    offset += sizeof(uint8_t);
-    result = getParam(arcseckeys::MIN_TOTAL_VALUE, param);
-    if (result != RETURN_OK) {
-        return result;
-    }
-    adduint16(param, buffer + offset);
-    offset += sizeof(uint16_t);
-    result = getParam(arcseckeys::MAX_TOTAL_VALUE, param);
-    if (result != RETURN_OK) {
-        return result;
-    }
-    adduint16(param, buffer + offset);
-    offset += sizeof(uint16_t);
-    result = getParam(arcseckeys::MIN_BRIGHT_NEIGHBOURS, param);
-    if (result != RETURN_OK) {
-        return result;
-    }
-    adduint16(param, buffer + offset);
-    offset += sizeof(uint16_t);
-    result = getParam(arcseckeys::MAX_BRIGHT_NEIGHBOURS, param);
-    if (result != RETURN_OK) {
-        return result;
-    }
-    adduint16(param, buffer + offset);
-    offset += sizeof(uint16_t);
-    result = getParam(arcseckeys::MAX_PIXEL_TO_CONSIDER, param);
-    if (result != RETURN_OK) {
-        return result;
-    }
-    adduint32(param, buffer + offset);
-    offset += sizeof(uint32_t);
-    result = getParam(arcseckeys::SIGNAL_THRESHOLD, param);
-    if (result != RETURN_OK) {
-        return result;
-    }
-    adduint8(param, buffer + offset);
-    offset += sizeof(uint8_t);
-    result = getParam(arcseckeys::DARK_THRESHOLD, param);
-    if (result != RETURN_OK) {
-        return result;
-    }
-    adduint8(param, buffer + offset);
-    offset += sizeof(uint8_t);
-    result = getParam(arcseckeys::ENABLE_HISTOGRAM, param);
-    if (result != RETURN_OK) {
-        return result;
-    }
-    adduint8(param, buffer + offset);
-    offset += sizeof(uint8_t);
-    result = getParam(arcseckeys::ENABLE_CONTRAST, param);
-    if (result != RETURN_OK) {
-        return result;
-    }
-    adduint8(param, buffer + offset);
-    offset += sizeof(uint8_t);
-    result = getParam(arcseckeys::BIN_MODE, param);
-    if (result != RETURN_OK) {
-        return result;
-    }
-    adduint8(param, buffer + offset);
-    offset += sizeof(uint8_t);
     return RETURN_OK;
 }
diff --git a/bsp_q7s/devices/startracker/StarTrackerJsonCommands.h b/bsp_q7s/devices/startracker/StarTrackerJsonCommands.h
index 153ef8a7..868c18ea 100644
--- a/bsp_q7s/devices/startracker/StarTrackerJsonCommands.h
+++ b/bsp_q7s/devices/startracker/StarTrackerJsonCommands.h
@@ -12,6 +12,7 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "ArcsecJsonParamBase.h"
 
+
 /**
  * @brief   Generates command to set the limit parameters
  *
@@ -30,6 +31,7 @@ private:
     virtual ReturnValue_t createCommand(uint8_t* buffer) override;
 };
 
+
 /**
  * @brief   Generates the command to configure the tracking algorithm.
  *
@@ -49,6 +51,7 @@ private:
 
 };
 
+
 /**
  * @brief   Generates the command to set the mounting quaternion
  *
@@ -68,6 +71,7 @@ private:
 
 };
 
+
 /**
  * @brief   Generates the command to set the mounting quaternion
  *
@@ -87,6 +91,7 @@ private:
 
 };
 
+
 /**
  * @brief   Generates the command to configure the blob algorithm
  *
@@ -106,6 +111,7 @@ private:
 
 };
 
+
 /**
  * @brief   Generates the command to configure the centroiding algorithm
  *
@@ -119,7 +125,88 @@ public:
 
 private:
 
-    static const  size_t COMMAND_SIZE = 24;
+    static const  size_t COMMAND_SIZE = 47;
+
+    ReturnValue_t createCommand(uint8_t* buffer) override;
+
+};
+
+
+/**
+ * @brief   Generates the command to configure the LISA (lost in space algorithm)
+ *
+ */
+class Lisa : public ArcsecJsonParamBase {
+public:
+
+    Lisa();
+
+    size_t getSize();
+
+private:
+
+    static const  size_t COMMAND_SIZE = 48;
+
+    ReturnValue_t createCommand(uint8_t* buffer) override;
+
+};
+
+
+/**
+ * @brief   Generates the command to configure the matching algorithm
+ *
+ */
+class Matching : public ArcsecJsonParamBase {
+public:
+
+    Matching();
+
+    size_t getSize();
+
+private:
+
+    static const  size_t COMMAND_SIZE = 10;
+
+    ReturnValue_t createCommand(uint8_t* buffer) override;
+
+};
+
+
+/**
+ * @brief   Generates the command to configure the validation parameters
+ *
+ */
+class Validation : public ArcsecJsonParamBase {
+public:
+
+    Validation();
+
+    size_t getSize();
+
+private:
+
+    static const  size_t COMMAND_SIZE = 12;
+
+    ReturnValue_t createCommand(uint8_t* buffer) override;
+
+};
+
+
+/**
+ * @brief   Generates command to configure the mechanism of automatically switching between the
+ *          LISA and other algorithms.
+ *
+ */
+class Algo : public ArcsecJsonParamBase {
+public:
+
+    Algo();
+
+    size_t getSize();
+
+private:
+
+    static const  size_t COMMAND_SIZE = 13;
 
     ReturnValue_t createCommand(uint8_t* buffer) override;