bsp_q7s/devices/startracker/StarTrackerDefinitions.h

@@ -211,7 +211,33 @@ enum PoolIds: lp_id_t {
     CAM_REG3,
     CAM_VAL3,
     CAM_REG4,
-    CAM_VAL4
+    CAM_VAL4,
+    LIMITS_ACTION,
+    LIMITS_FPGA18CURRENT,
+    LIMITS_FPGA25CURRENT,
+    LIMITS_FPGA10CURRENT,
+    LIMITS_MCUCURRENT,
+    LIMITS_CMOS21CURRENT,
+    LIMITS_CMOSPIXCURRENT,
+    LIMITS_CMOS33CURRENT,
+    LIMITS_CMOSVRESCURRENT,
+    LIMITS_CMOSTEMPERATURE,
+    LIMITS_MCUTEMPERATURE,
+    BLOB_MODE,
+    BLOB_MIN_VALUE,
+    BLOB_MIN_DISTANCE,
+    BLOB_NEIGHBOUR_DISTANCE,
+    BLOB_NEIGHBOUR_BRIGHTPIXELS,
+    BLOB_MIN_TOTAL_VALUE,
+    BLOB_MAX_TOTAL_VALUE,
+    BLOB_MIN_BRIGHT_NEIGHBOURS,
+    BLOB_MAX_BRIGHT_NEIGHBOURS,
+    BLOB_MAX_PIXELSTOCONSIDER,
+    BLOB_SIGNAL_THRESHOLD,
+    BLOB_DARK_THRESHOLD,
+    BLOB_ENABLE_HISTOGRAM,
+    BLOB_ENABLE_CONTRAST,
+    BLOB_BIN_MODE
 };
 
 static const DeviceCommandId_t PING_REQUEST = 0;
@@ -260,7 +286,9 @@ static const DeviceCommandId_t DOWNLOAD_FPGA_IMAGE = 63;
 static const DeviceCommandId_t CHANGE_FPGA_DOWNLOAD_FILE = 64;
 static const DeviceCommandId_t UPLOAD_FPGA_IMAGE = 65;
 static const DeviceCommandId_t FPGA_ACTION = 66;
-static const DeviceCommandId_t REQ_CAMERA_PARAMS = 67;
+static const DeviceCommandId_t REQ_CAMERA = 67;
+static const DeviceCommandId_t REQ_LIMITS = 68;
+static const DeviceCommandId_t REQ_BLOB_PARAMS = 69;
 static const DeviceCommandId_t NONE = 0xFFFFFFFF;
 
 static const uint32_t VERSION_SET_ID = REQ_VERSION;
@@ -276,7 +304,9 @@ 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_PARAMS;
+static const uint32_t CAMERA_SET_ID = REQ_CAMERA;
+static const uint32_t LIMITS_SET_ID = REQ_LIMITS;
+static const uint32_t BLOB_SET_ID = REQ_BLOB_PARAMS;
 
 /** Max size of unencoded frame */
 static const size_t MAX_FRAME_SIZE = 1200;
@@ -295,6 +325,8 @@ 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 = 15;
+static const uint8_t LIMITS_SET_ENTRIES = 11;
+static const uint8_t BLOB_SET_ENTRIES = 15;
 
 // Action, parameter and telemetry IDs
 namespace ID {
@@ -1289,5 +1321,112 @@ public:
                 << static_cast<unsigned int>(this->val4.value) << std::endl;
     }
 };
+
+/**
+ * @brief   Will store the requested limits
+ */
+class LimitsSet: public StaticLocalDataSet<LIMITS_SET_ENTRIES> {
+public:
+
+    // Size of dataset
+    static const size_t SIZE = 41;
+
+    LimitsSet(HasLocalDataPoolIF* owner) :
+            StaticLocalDataSet(owner, LIMITS_SET_ID) {
+    }
+
+    LimitsSet(object_id_t objectId) :
+            StaticLocalDataSet(sid_t(objectId, LIMITS_SET_ID)) {
+    }
+
+    lp_var_t<uint8_t> action = lp_var_t<uint8_t>(sid.objectId, PoolIds::LIMITS_ACTION, this);
+    lp_var_t<float> fpga18current = lp_var_t<float>(sid.objectId, PoolIds::LIMITS_FPGA18CURRENT, this);
+    lp_var_t<float> fpga25current = lp_var_t<float>(sid.objectId, PoolIds::LIMITS_FPGA25CURRENT, this);
+    lp_var_t<float> fpga10current = lp_var_t<float>(sid.objectId, PoolIds::LIMITS_FPGA10CURRENT, this);
+    lp_var_t<float> mcuCurrent = lp_var_t<float>(sid.objectId, PoolIds::LIMITS_MCUCURRENT, this);
+    lp_var_t<float> cmos21current = lp_var_t<float>(sid.objectId, PoolIds::LIMITS_CMOS21CURRENT, this);
+    lp_var_t<float> cmosPixCurrent = lp_var_t<float>(sid.objectId, PoolIds::LIMITS_CMOSPIXCURRENT, this);
+    lp_var_t<float> cmos33current = lp_var_t<float>(sid.objectId, PoolIds::LIMITS_CMOS33CURRENT, this);
+    lp_var_t<float> cmosVresCurrent = lp_var_t<float>(sid.objectId, PoolIds::LIMITS_CMOSVRESCURRENT, this);
+    lp_var_t<float> cmosTemperature = lp_var_t<float>(sid.objectId, PoolIds::LIMITS_CMOSTEMPERATURE, this);
+
+    void printSet() {
+        PoolReadGuard rg(this);
+        sif::info << "CameraSet::printSet: action: " << static_cast<unsigned int>(this->action.value)
+                << std::endl;
+        sif::info << "CameraSet::printSet: FPGA18Current: " << this->fpga18current << std::endl;
+        sif::info << "CameraSet::printSet: FPGA25Current: " << this->fpga25current << std::endl;
+        sif::info << "CameraSet::printSet: FPGA10Current: " << this->fpga10current << std::endl;
+        sif::info << "CameraSet::printSet: MCUCurrent: " << this->mcuCurrent << std::endl;
+        sif::info << "CameraSet::printSet: CMOS21Current: " << this->cmos21current << std::endl;
+        sif::info << "CameraSet::printSet: CMOSPixCurrent: " << this->cmosPixCurrent << std::endl;
+        sif::info << "CameraSet::printSet: CMOS33Current: " << this->cmos33current << std::endl;
+        sif::info << "CameraSet::printSet: CMOSVResCurrent: " << this->cmosVresCurrent << std::endl;
+        sif::info << "CameraSet::printSet: CMOSTemperature: " << this->cmosTemperature << std::endl;
+    }
+};
+
+/**
+ * @brief   Will store the request of the blob parameters.
+ */
+class BlobSet: public StaticLocalDataSet<BLOB_SET_ENTRIES> {
+public:
+
+    // Size of dataset
+    static const size_t SIZE = 22;
+
+    BlobSet(HasLocalDataPoolIF* owner) :
+            StaticLocalDataSet(owner, BLOB_SET_ID) {
+    }
+
+    BlobSet(object_id_t objectId) :
+            StaticLocalDataSet(sid_t(objectId, BLOB_SET_ID)) {
+    }
+
+    lp_var_t<uint8_t> mode = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_MODE, this);
+    lp_var_t<uint8_t> minValue = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_MIN_VALUE, this);
+    lp_var_t<uint8_t> minDistance = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_MIN_DISTANCE, this);
+    lp_var_t<uint8_t> neighbourDistance = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_NEIGHBOUR_DISTANCE, this);
+    lp_var_t<uint8_t> neighbourBrightPixels = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_NEIGHBOUR_BRIGHTPIXELS, this);
+    lp_var_t<uint16_t> minTotalValue = lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOB_MIN_TOTAL_VALUE, this);
+    lp_var_t<uint16_t> maxTotalValue = lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOB_MAX_TOTAL_VALUE, this);
+    lp_var_t<uint16_t> minBrightNeighbours = lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOB_MIN_BRIGHT_NEIGHBOURS, this);
+    lp_var_t<uint16_t> maxBrightNeighbours = lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOB_MAX_BRIGHT_NEIGHBOURS, this);
+    lp_var_t<uint32_t> maxPixelsToConsider = lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOB_MAX_PIXELSTOCONSIDER, this);
+    lp_var_t<uint8_t> signalThreshold = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_SIGNAL_THRESHOLD, this);
+    lp_var_t<uint8_t> darkThreshold = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_DARK_THRESHOLD, this);
+    lp_var_t<uint8_t> enableContrast = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_ENABLE_CONTRAST, this);
+    lp_var_t<uint8_t> enableBinMode = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_BIN_MODE, this);
+
+    void printSet() {
+        PoolReadGuard rg(this);
+        sif::info << "BlobSet::printSet: mode: " << static_cast<unsigned int>(this->mode.value)
+                << std::endl;
+        sif::info << "BlobSet::printSet: minValue: "
+                << static_cast<unsigned int>(this->minValue.value) << std::endl;
+        sif::info << "BlobSet::printSet: minDistance: "
+                << static_cast<unsigned int>(this->minDistance.value) << std::endl;
+        sif::info << "BlobSet::printSet: neighboutDistance: "
+                << static_cast<unsigned int>(this->neighbourDistance.value) << std::endl;
+        sif::info << "BlobSet::printSet: neighboutBrightPixels: "
+                << static_cast<unsigned int>(this->neighbourBrightPixels.value) << std::endl;
+        sif::info << "BlobSet::printSet: minTotalValue: " << this->minTotalValue << std::endl;
+        sif::info << "BlobSet::printSet: maxTotalValue: " << this->maxTotalValue << std::endl;
+        sif::info << "BlobSet::printSet: minBrightNeighbours: " << this->minBrightNeighbours
+                << std::endl;
+        sif::info << "BlobSet::printSet: maxBrightNeighbours: " << this->maxBrightNeighbours
+                << std::endl;
+        sif::info << "BlobSet::printSet: maxPixelsToConsider: " << this->maxPixelsToConsider
+                << std::endl;
+        sif::info << "BlobSet::printSet: signalThreshold: "
+                << static_cast<unsigned int>(this->signalThreshold.value) << std::endl;
+        sif::info << "BlobSet::printSet: darkThreshold: "
+                << static_cast<unsigned int>(this->darkThreshold.value) << std::endl;
+        sif::info << "BlobSet::printSet: enableContrast: "
+                << static_cast<unsigned int>(this->enableContrast.value) << std::endl;
+        sif::info << "BlobSet::printSet: enableBinMode: "
+                << static_cast<unsigned int>(this->enableBinMode.value) << std::endl;
+    }
+};
 }
 #endif /* MISSION_STARTRACKER_DEFINITIONS_H_ */

bsp_q7s/devices/startracker/StarTrackerHandler.cpp

@@ -18,8 +18,8 @@ StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF,
         CookieIF * comCookie, StrHelper* strHelper) :
         DeviceHandlerBase(objectId, comIF, comCookie), temperatureSet(this), versionSet(this), powerSet(
                 this), interfaceSet(this), timeSet(this), solutionSet(this), histogramSet(this), contrastSet(
-                this), checksumSet(this), downloadCentroidSet(this), downloadMatchedStar(this),
+                this), checksumSet(this), downloadCentroidSet(this), downloadMatchedStar(this), downloadDbImage(
-                downloadDbImage(this), downloadBlobPixel(this), cameraSet(this), strHelper(
+                this), downloadBlobPixel(this), cameraSet(this), limitsSet(this), blobSet(this), strHelper(
                 strHelper) {
     if (comCookie == nullptr) {
         sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl;
@@ -496,10 +496,18 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
         result = prepareFpgaActionCommand(commandData, commandDataLen);
         return result;
     }
-    case (StarTracker::REQ_CAMERA_PARAMS): {
+    case (StarTracker::REQ_CAMERA): {
         result = prepareRequestCameraParams();
         return result;
     }
+    case (StarTracker::REQ_LIMITS): {
+        result = prepareRequestLimitsParams();
+        return result;
+    }
+    case (StarTracker::REQ_BLOB_PARAMS): {
+        result = prepareRequestBlobParams();
+        return result;
+    }
     default:
         return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
     }
@@ -578,7 +586,11 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
             StarTracker::MAX_FRAME_SIZE * 2 + 2);
     this->insertInCommandAndReplyMap(StarTracker::FPGA_ACTION, 3, nullptr,
             StarTracker::MAX_FRAME_SIZE * 2 + 2);
-    this->insertInCommandAndReplyMap(StarTracker::REQ_CAMERA_PARAMS, 3, nullptr,
+    this->insertInCommandAndReplyMap(StarTracker::REQ_CAMERA, 3, nullptr,
+            StarTracker::MAX_FRAME_SIZE * 2 + 2);
+    this->insertInCommandAndReplyMap(StarTracker::REQ_LIMITS, 3, nullptr,
+            StarTracker::MAX_FRAME_SIZE * 2 + 2);
+    this->insertInCommandAndReplyMap(StarTracker::REQ_BLOB_PARAMS, 3, nullptr,
             StarTracker::MAX_FRAME_SIZE * 2 + 2);
 }
 
@@ -738,10 +750,18 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id, con
         result = handleSetParamReply();
         break;
     }
-    case (StarTracker::REQ_CAMERA_PARAMS): {
+    case (StarTracker::REQ_CAMERA): {
         handleParamRequest(cameraSet, StarTracker::CameraSet::SIZE);
         break;
     }
+    case (StarTracker::REQ_LIMITS): {
+        handleParamRequest(limitsSet, StarTracker::LimitsSet::SIZE);
+        break;
+    }
+    case (StarTracker::REQ_BLOB_PARAMS): {
+        handleParamRequest(blobSet, StarTracker::BlobSet::SIZE);
+        break;
+    }
     default: {
         sif::debug << "StarTrackerHandler::interpretDeviceReply: Unknown device reply id:" << id
                 << std::endl;
@@ -966,6 +986,34 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
     localDataPoolMap.emplace(StarTracker::CAM_VAL3, new PoolEntry<uint8_t>( { 0 }));
     localDataPoolMap.emplace(StarTracker::CAM_REG4, new PoolEntry<uint8_t>( { 0 }));
     localDataPoolMap.emplace(StarTracker::CAM_VAL4, new PoolEntry<uint8_t>( { 0 }));
+
+    localDataPoolMap.emplace(StarTracker::LIMITS_ACTION, new PoolEntry<uint8_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::LIMITS_FPGA18CURRENT, new PoolEntry<float>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::LIMITS_FPGA25CURRENT, new PoolEntry<float>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::LIMITS_FPGA10CURRENT, new PoolEntry<float>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::LIMITS_MCUCURRENT, new PoolEntry<float>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::LIMITS_CMOS21CURRENT, new PoolEntry<float>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::LIMITS_CMOSPIXCURRENT, new PoolEntry<float>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::LIMITS_CMOS33CURRENT, new PoolEntry<float>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::LIMITS_CMOSVRESCURRENT, new PoolEntry<float>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::LIMITS_CMOSTEMPERATURE, new PoolEntry<float>( { 0 }));
+
+    localDataPoolMap.emplace(StarTracker::BLOB_MODE, new PoolEntry<uint8_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_MIN_VALUE, new PoolEntry<uint8_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_MIN_DISTANCE, new PoolEntry<uint8_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_NEIGHBOUR_DISTANCE, new PoolEntry<uint8_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_NEIGHBOUR_BRIGHTPIXELS, new PoolEntry<uint8_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_NEIGHBOUR_BRIGHTPIXELS, new PoolEntry<uint8_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_MIN_TOTAL_VALUE, new PoolEntry<uint16_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_MAX_TOTAL_VALUE, new PoolEntry<uint16_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_MIN_BRIGHT_NEIGHBOURS, new PoolEntry<uint16_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_MAX_BRIGHT_NEIGHBOURS, new PoolEntry<uint16_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_MAX_PIXELSTOCONSIDER, new PoolEntry<uint32_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_SIGNAL_THRESHOLD, new PoolEntry<uint8_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_DARK_THRESHOLD, new PoolEntry<uint8_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_ENABLE_HISTOGRAM, new PoolEntry<uint8_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_ENABLE_CONTRAST, new PoolEntry<uint8_t>( { 0 }));
+    localDataPoolMap.emplace(StarTracker::BLOB_BIN_MODE, new PoolEntry<uint8_t>( { 0 }));
     return RETURN_OK;
 }
 
@@ -1127,7 +1175,15 @@ ReturnValue_t StarTrackerHandler::scanForGetParameterReply(DeviceCommandId_t *fo
     const uint8_t* reply = dataLinkLayer.getReply();
     switch (*reply) {
         case (StarTracker::ID::CAMERA): {
-            *foundId = StarTracker::REQ_CAMERA_PARAMS;
+            *foundId = StarTracker::REQ_CAMERA;
+            break;
+        }
+        case (StarTracker::ID::LIMITS): {
+            *foundId = StarTracker::REQ_LIMITS;
+            break;
+        }
+        case (StarTracker::ID::BLOB): {
+            *foundId = StarTracker::REQ_BLOB_PARAMS;
             break;
         }
         default: {
@@ -1749,7 +1805,6 @@ ReturnValue_t StarTrackerHandler::prepareFpgaActionCommand(const uint8_t* comman
 }
 
 ReturnValue_t StarTrackerHandler::prepareRequestCameraParams() {
-    struct Camera req;
     uint32_t length = 0;
     arc_pack_camera_parameter_req(commandBuffer, &length);
     dataLinkLayer.encodeFrame(commandBuffer, length);
@@ -1758,6 +1813,24 @@ ReturnValue_t StarTrackerHandler::prepareRequestCameraParams() {
     return RETURN_OK;
 }
 
+ReturnValue_t StarTrackerHandler::prepareRequestLimitsParams() {
+    uint32_t length = 0;
+    arc_pack_limits_parameter_req(commandBuffer, &length);
+    dataLinkLayer.encodeFrame(commandBuffer, length);
+    rawPacket = dataLinkLayer.getEncodedFrame();
+    rawPacketLen = dataLinkLayer.getEncodedLength();
+    return RETURN_OK;
+}
+
+ReturnValue_t StarTrackerHandler::prepareRequestBlobParams() {
+    uint32_t length = 0;
+    arc_pack_blob_parameter_req(commandBuffer, &length);
+    dataLinkLayer.encodeFrame(commandBuffer, length);
+    rawPacket = dataLinkLayer.getEncodedFrame();
+    rawPacketLen = dataLinkLayer.getEncodedLength();
+    return RETURN_OK;
+}
+
 ReturnValue_t StarTrackerHandler::handleSetParamReply() {
     const uint8_t* reply = dataLinkLayer.getReply();
     uint8_t status = *(reply + STATUS_OFFSET);

bsp_q7s/devices/startracker/StarTrackerHandler.h

@@ -262,6 +262,8 @@ private:
     StarTracker::DownloadDBImage downloadDbImage;
     StarTracker::DownloadBlobPixel downloadBlobPixel;
     StarTracker::CameraSet cameraSet;
+    StarTracker::LimitsSet limitsSet;
+    StarTracker::BlobSet blobSet;
 
     // Pointer to object responsible for uploading and downloading images to/from the star tracker
     StrHelper* strHelper = nullptr;
@@ -500,6 +502,16 @@ private:
      */
     ReturnValue_t prepareRequestCameraParams();
 
+    /**
+     * @brief   Will fill the command buffer with the command to request the set limits.
+     */
+    ReturnValue_t prepareRequestLimitsParams();
+
+    /**
+     * @brief   Will fill the command buffer with the command to request the set blob parameters.
+     */
+    ReturnValue_t prepareRequestBlobParams();
+
     /**
      * @brief   Handles action replies with datasets.
      */

tmtc

@@ -1 +1 @@
-Subproject commit 6270d90f98b4ec694b6d543ce9a9ddd49ba743f9
+Subproject commit 672f2339d7504c83d953cc4eecca6057ff920909