TlmArchive

PROVESFlightControllerReference/Components/AntennaDeployer/AntennaDeployer.cpp

@@ -86,6 +86,11 @@ void AntennaDeployer ::schedIn_handler(FwIndexType portNum, U32 context) {
     }
 }
 
+bool AntennaDeployer ::deploymentStateGet_handler(FwIndexType portNum) {
+    (void)portNum;
+    return this->readDeploymentState();
+}
+
 // ----------------------------------------------------------------------
 // Command handler implementations
 // ----------------------------------------------------------------------

PROVESFlightControllerReference/Components/AntennaDeployer/AntennaDeployer.fpp

@@ -4,6 +4,9 @@ module Components {
         DEPLOY_RESULT_ABORT   @< Deployment aborted via command
         DEPLOY_RESULT_FAILED  @< Deployment failed after exhausting retries
     }
+
+    @ Port for querying the persistent antenna deployment state
+    port GetDeploymentState -> bool
 }
 
 module Components {
@@ -79,6 +82,9 @@ module Components {
         @ Port receiving calls from the rate group
         sync input port schedIn: Svc.Sched
 
+        @ Port returning whether antenna deployment has completed
+        sync input port deploymentStateGet: Components.GetDeploymentState
+
         @ Port signaling the burnwire component to start heating
         output port burnStart: Fw.Signal
 

PROVESFlightControllerReference/Components/AntennaDeployer/AntennaDeployer.hpp

@@ -33,6 +33,7 @@ class AntennaDeployer final : public AntennaDeployerComponentBase {
     // Handler implementations
     // ----------------------------------------------------------------------
     void schedIn_handler(FwIndexType portNum, U32 context) override;
+    bool deploymentStateGet_handler(FwIndexType portNum) override;
 
     // ----------------------------------------------------------------------
     // Command handlers

PROVESFlightControllerReference/Components/CMakeLists.txt

@@ -26,3 +26,4 @@ add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/StartupManager/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/TcSecurityDeframer/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/ThermalManager/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Watchdog")
+add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/TlmArchive/")

PROVESFlightControllerReference/Components/TlmArchive/CMakeLists.txt

@@ -0,0 +1,6 @@
+register_fprime_library(
+    AUTOCODER_INPUTS
+        "${CMAKE_CURRENT_LIST_DIR}/TlmArchive.fpp"
+    SOURCES
+        "${CMAKE_CURRENT_LIST_DIR}/TlmArchive.cpp"
+)

PROVESFlightControllerReference/Components/TlmArchive/TlmArchive.cpp

@@ -0,0 +1,226 @@
+// ======================================================================
+// \title  TlmArchive.cpp
+// \author aychar
+// \brief  cpp file for TlmArchive component implementation class
+// ======================================================================
+
+#include "PROVESFlightControllerReference/Components/TlmArchive/TlmArchive.hpp"
+
+#include <cstdio>
+#include <cstring>
+
+#include "Fw/Com/ComPacket.hpp"
+#include "Os/File.hpp"
+#include "Os/FileSystem.hpp"
+#include "Os/Models/FileStatusEnumAc.hpp"
+
+namespace Components {
+
+namespace {
+
+constexpr const char* TLM_DIRECTORY = "//tlm";
+constexpr const char* PRE_DEPLOYMENT_TLM_PATH = "//tlm/pre_deployment.csv";
+constexpr char CSV_HEADER[] = "format_version,packet_size_bytes,packet_hex\n";
+constexpr char HEX_DIGITS[] = "0123456789ABCDEF";
+constexpr FwSizeType CSV_RECORD_BUFFER_SIZE = (FW_COM_BUFFER_MAX_SIZE * 2) + sizeof(CSV_HEADER) + 32;
+
+// Only packetized telemetry IDs in this list are stored in the archive.
+constexpr FwTlmPacketizeIdType STORED_PACKET_IDS[] = {
+    1,  // Beacon
+    7,  // Imu
+};
+
+bool shouldStorePacket(const Fw::ComBuffer& data) {
+    Fw::ComBuffer packet = data;
+    FwPacketDescriptorType descriptor = 0;
+    FwTlmPacketizeIdType packetId = 0;
+
+    if ((packet.deserializeTo(descriptor) != Fw::FW_SERIALIZE_OK) ||
+        (descriptor != static_cast<FwPacketDescriptorType>(Fw::ComPacketType::FW_PACKET_PACKETIZED_TLM)) ||
+        (packet.deserializeTo(packetId) != Fw::FW_SERIALIZE_OK)) {
+        return false;
+    }
+
+    for (const FwTlmPacketizeIdType storedPacketId : STORED_PACKET_IDS) {
+        if (packetId == storedPacketId) {
+            return true;
+        }
+    }
+    return false;
+}
+
+}  // namespace
+
+TlmArchive ::TlmArchive(const char* const compName) : TlmArchiveComponentBase(compName) {}
+
+TlmArchive ::~TlmArchive() {}
+
+void TlmArchive::clearPacketQueue() {
+    Os::ScopeLock lock(this->m_queueMutex);
+    this->m_queueHead = 0;
+    this->m_queueTail = 0;
+    this->m_queueSize = 0;
+}
+
+void TlmArchive::comIn_handler(FwIndexType portNum, Fw::ComBuffer& data, U32 context) {
+    (void)portNum;
+    (void)context;
+
+    Fw::ParamValid maxFailuresValid;
+    const U32 maxFailures = this->paramGet_MAX_FAILURES(maxFailuresValid);
+    FW_ASSERT(maxFailuresValid == Fw::ParamValid::VALID || maxFailuresValid == Fw::ParamValid::DEFAULT);
+
+    Fw::ParamValid maxFileSizeValid;
+    const U32 maxFileSize = this->paramGet_MAX_FILE_SIZE(maxFileSizeValid);
+    FW_ASSERT(maxFileSizeValid == Fw::ParamValid::VALID || maxFileSizeValid == Fw::ParamValid::DEFAULT);
+
+    if (this->m_failures.load() >= maxFailures) {
+        this->log_WARNING_HI_FailureLimitReached(maxFailures);
+        return;
+    } else if (this->m_fileSize.load() >= maxFileSize) {
+        this->clearPacketQueue();
+        this->log_WARNING_LO_SizeLimitReached(maxFileSize);
+        return;
+    } else if (this->m_antennasDeployed.load()) {
+        this->log_WARNING_LO_AntennasDeployed();
+        return;
+    }
+
+    if (!shouldStorePacket(data)) {
+        return;
+    }
+
+    bool queueFull = false;
+    {
+        Os::ScopeLock lock(this->m_queueMutex);
+        if (this->m_queueSize >= PACKET_QUEUE_CAPACITY) {
+            queueFull = true;
+        } else {
+            this->m_packetQueue[this->m_queueTail] = data;
+            this->m_queueTail = (this->m_queueTail + 1) % PACKET_QUEUE_CAPACITY;
+            this->m_queueSize++;
+        }
+    }
+
+    if (queueFull) {
+        this->log_WARNING_HI_QueueFull(PACKET_QUEUE_CAPACITY);
+    } else {
+        this->log_WARNING_HI_QueueFull_ThrottleClear();
+    }
+}
+
+void TlmArchive::run_handler(FwIndexType portNum, U32 context) {
+    (void)portNum;
+    (void)context;
+
+    // Don't write for the first 30s of boot to attempt to mitigate
+    // any conflicts with other filesystem writes/actions
+    if (this->m_ticks <= 30) {
+        this->m_ticks++;
+        return;
+    }
+
+    Fw::ComBuffer packet;
+    {
+        Os::ScopeLock lock(this->m_queueMutex);
+        if (this->m_queueSize == 0) {
+            return;
+        }
+        packet = this->m_packetQueue[this->m_queueHead];
+        this->m_queueHead = (this->m_queueHead + 1) % PACKET_QUEUE_CAPACITY;
+        this->m_queueSize--;
+    }
+
+    if (!this->m_antennasDeployed.load()) {
+        this->m_antennasDeployed.store(this->deploymentStateGet_out(0));
+    }
+
+    if (this->m_antennasDeployed.load()) {
+        return;
+    }
+
+    if (!this->m_directoryInitialized) {
+        if (Os::FileSystem::createDirectory(TLM_DIRECTORY, false) != Os::FileSystem::OP_OK) {
+            this->log_WARNING_HI_FileError(Fw::LogStringArg("create_directory"));
+            this->m_failures.fetch_add(1);
+            return;
+        }
+        if (Os::FileSystem::touch(PRE_DEPLOYMENT_TLM_PATH) != Os::FileSystem::OP_OK) {
+            this->log_WARNING_HI_FileError(Fw::LogStringArg("create_file"));
+            this->m_failures.fetch_add(1);
+            return;
+        }
+        this->m_directoryInitialized = true;
+    }
+
+    const FwSizeType packetSize = packet.getSize();
+    FwSizeType currentSize = this->m_fileSize.load();
+    Fw::ParamValid maxFileSizeValid;
+    const U32 maxFileSize = this->paramGet_MAX_FILE_SIZE(maxFileSizeValid);
+    FW_ASSERT(maxFileSizeValid == Fw::ParamValid::VALID || maxFileSizeValid == Fw::ParamValid::DEFAULT);
+    if (!this->m_fileSizeInitialized) {
+        const Os::FileSystem::Status sizeStatus = Os::FileSystem::getFileSize(PRE_DEPLOYMENT_TLM_PATH, currentSize);
+        if (sizeStatus != Os::FileSystem::OP_OK) {
+            this->log_WARNING_HI_FileError(Fw::LogStringArg("get_file_size"));
+            this->m_failures.fetch_add(1);
+            return;
+        }
+        this->m_fileSize.store(static_cast<U32>(currentSize));
+        this->m_fileSizeInitialized = true;
+    }
+
+    char csvRecord[CSV_RECORD_BUFFER_SIZE];
+    FwSizeType recordSize = 0;
+    if (currentSize == 0) {
+        static_assert(sizeof(CSV_HEADER) > 1, "CSV header must not be empty");
+        (void)std::memcpy(csvRecord, CSV_HEADER, sizeof(CSV_HEADER) - 1);
+        recordSize = sizeof(CSV_HEADER) - 1;
+    }
+
+    const int prefixSize = std::snprintf(&csvRecord[recordSize], sizeof(csvRecord) - recordSize, "1,%llu,",
+                                         static_cast<unsigned long long>(packetSize));
+    if ((prefixSize < 0) || (static_cast<FwSizeType>(prefixSize) >= (sizeof(csvRecord) - recordSize))) {
+        this->log_WARNING_HI_FileError(Fw::LogStringArg("format_record"));
+        this->m_failures.fetch_add(1);
+        return;
+    }
+    recordSize += static_cast<FwSizeType>(prefixSize);
+
+    const U8* const packetBytes = packet.getBuffAddr();
+    for (FwSizeType index = 0; index < packetSize; index++) {
+        csvRecord[recordSize++] = HEX_DIGITS[(packetBytes[index] >> 4) & 0x0F];
+        csvRecord[recordSize++] = HEX_DIGITS[packetBytes[index] & 0x0F];
+    }
+    csvRecord[recordSize++] = '\n';
+
+    if (currentSize > maxFileSize) {
+        this->clearPacketQueue();
+        this->log_WARNING_LO_SizeLimitReached(maxFileSize);
+        return;
+    }
+
+    this->log_ACTIVITY_LO_WriteStart();
+    Os::File file;
+    const Os::File::Status openStatus = file.open(PRE_DEPLOYMENT_TLM_PATH, Os::File::OPEN_APPEND);
+    if (openStatus != Os::File::OP_OK) {
+        this->log_WARNING_HI_FileError(Fw::LogStringArg("open_append"));
+        this->m_failures.fetch_add(1);
+        return;
+    }
+
+    FwSizeType writtenSize = recordSize;
+    const Os::File::Status writeStatus =
+        file.write(reinterpret_cast<const U8*>(csvRecord), writtenSize, Os::File::WaitType::WAIT);
+    if ((writeStatus != Os::File::OP_OK) || (writtenSize != recordSize)) {
+        this->log_WARNING_HI_WriteError(Os::FileStatus(static_cast<Os::FileStatus::T>(writeStatus)), recordSize,
+                                        writtenSize);
+        this->m_failures.fetch_add(1);
+        file.close();
+        return;
+    }
+    file.close();
+
+    this->m_fileSize.fetch_add(static_cast<U32>(writtenSize));
+}
+
+}  // namespace Components

PROVESFlightControllerReference/Components/TlmArchive/TlmArchive.fpp

@@ -0,0 +1,78 @@
+module Components {
+    @ Stores telemetry generated before antenna deployment
+    passive component TlmArchive {
+        @ Telemetry packet to enqueue for deferred archival
+        sync input port comIn: Fw.Com
+
+        @ Drains one queued telemetry packet and performs filesystem work
+        sync input port run: Svc.Sched
+
+        @ Port for checking whether antenna deployment has completed
+        output port deploymentStateGet: Components.GetDeploymentState
+
+        @ Maximum archive size in bytes
+        param MAX_FILE_SIZE: U32 default 50000 id 0
+
+        @ Number of counted filesystem failures that disables archiving
+        param MAX_FAILURES: U32 default 3 id 1
+
+        @ Report when file write has started
+        event WriteStart severity activity low format "Beginning telemetry archival to pre_deployment.csv" throttle 1
+
+        @ Reports that a packet could not be enqueued because the queue is full
+        event QueueFull(
+            capacity: FwSizeType @< Maximum number of queued telemetry packets
+        ) severity warning high format "Telemetry archive packet queue is full at {} packets" throttle 1
+
+        @ Reports archive initialization, size, and open failures
+        event FileError(
+            operation: string @< Filesystem operation that failed
+        ) severity warning high \
+          format "Pre-deployment telemetry archive operation failed: {}"
+
+        @ Reports failed and incomplete archive writes
+        event WriteError(
+            status: Os.FileStatus @< File write status
+            requested: FwSizeType @< Requested byte count
+            written: FwSizeType @< Reported byte count
+        ) severity warning high \
+          format "Pre-deployment telemetry archive write failed: status {}, requested {}, wrote {}"
+
+        @ Reports when telemetry archiving is disabled due to hitting the failure limit
+        event FailureLimitReached(
+            count: U32
+        ) severity warning high format "{} filesystem failures counted; disabling further telemetry writes." throttle 1
+
+        @ Reports when telemetry archiving is disabled due to antennas being deployed
+        event AntennasDeployed() severity warning low format "Antennas deployed; disabling further telemetry writes." throttle 1
+
+        @ Reports when telemetry archiving is disabled due to pre_deployment.csv hitting the size limit
+        event SizeLimitReached(
+            maxSize: U32
+        ) severity warning low format "pre_deployment.csv file size limit of {}b reached; disabling further telemetry writes." throttle 1
+
+        @ Port for requesting the current time
+        time get port timeCaller
+
+        @ Port for sending command registrations
+        command reg port cmdRegOut
+
+        @ Port for receiving commands
+        command recv port cmdIn
+
+        @ Port for sending command responses
+        command resp port cmdResponseOut
+
+        @ Port for sending textual representation of events
+        text event port logTextOut
+
+        @ Port for sending events to downlink
+        event port logOut
+
+        @ Port for getting parameter values
+        param get port prmGetOut
+
+        @ Port for setting parameter values
+        param set port prmSetOut
+    }
+}