Work/dp catalog (#2713)

* Starting on FDD for DpCatalog

* More DpCatalog SDD edits

* More refined DpCatalog requirements

* Starting prototype code

* Working on DpCatalog build command

* More DpCatalog work

* More DpCatalog work

* More work on reading DP headers

* More work...

* Continued work

* Spelling fixes

* More spelling fixes

* First run of init unit test

* One DP works

* Refactor unit test helpers

* Working on multiple DPs

* More work on multiple DPs

* Fixed filesRead bug

* More merge fixes

* Adding DPs to SignalGen

* Adding DP components

* Added DP directory to DpWriter

* First working version of Data Products!

* Added missing FileDownlink connection

* Added early proto warning to SDD.

* Switched to Fw::FileNameString

* Fixed unit test compile

* Add missing override keyword

* Fix unit test override

* Fixed format specifiers

* Reformat code

* Revise DpWriter uts

* Revise dp writer

* Revise dp writer

* Removed extra ;

* Fix markdown broken links

* Updated SDD to force CI to run again

* Adding async DP request example

* Working on async example

* Still working on async DP

* Remove test printf

* Another merge with F Prime devel

* Working on binary tree implementation

* Work in progress. Doesn't work yet

* Still working

* debug launch config

* fixed pre-launch run step

* Some progress on algo

* 2 and 3 nodes work

* Refactored some code

* Tree traverse seems to work!

* One transmitted test

* Fixed NULL to nullptr

* Fixed spelling

* Fixed memory alignment

* Starting on state file

* Fixed spelling - AGAIN

* Added reading of the state file

* Added function to get state for DP from state file

* Added state file data pruning function

* Code to update the state file

* Debugging DpCat

* More work on DPs

* Working on state file

* Added to spelling expect.txt

* fix double 'the'

* Testing with DpManager/SignalGen

* Some compile fixes

* Adding more test cases

* Fixed downlink bug

* Fix SignalGen unit test

* Updated SDD and some CI error fixes

* Fix SDD typo

* Working on docs

* Docs/comments updates

* Fix typo

---------

Co-authored-by: Robert L. Bocchino Jr. <[email protected]>

Author: timcanham

.github/actions/spelling/excludes.txt

@@ -11,6 +11,7 @@
 (?:^|/)pyproject.toml
 (?:^|/)requirements(?:-dev|-doc|-test|)\.txt$
 (?:^|/)vendor/
+(?:^|/)launch\.json$
 /doc/xml/
 /html/
 /third-party/

.github/actions/spelling/expect.txt

@@ -247,6 +247,7 @@ DPWRITER
 DRAINBUFFERS
 drv
 dspal
+Dstate
 Duerschmid
 duey
 dumparch
@@ -346,6 +347,7 @@ gencode
 genfile
 GENHUB
 genshi
+getblocks
 getchildren
 getcontext
 getdata
@@ -665,6 +667,7 @@ parseable
 PASSIVERATEGROUP
 PASSIVERATEGROUPIMPLTESTER
 pathmaker
+patsubst
 pbuild
 pcmake
 pcomp
@@ -819,6 +822,7 @@ SENDPARTIAL
 seqgen
 serializables
 setaffinity
+setblocks
 setdata
 setid
 setinheritsched

Ref/.gitignore

@@ -7,4 +7,4 @@ channels/
 events/
 dict/
 DpCat
-
+seq

Ref/SignalGen/Commands.fppi

@@ -1,5 +1,5 @@
 @ Signal Generator Settings
-async command SignalGen_Settings(
+async command Settings(
                                   Frequency: U32
                                   Amplitude: F32
                                   Phase: F32
@@ -8,16 +8,24 @@ async command SignalGen_Settings(
   opcode 0x00
 
 @ Toggle Signal Generator On/Off.
-async command SignalGen_Toggle \
+async command Toggle \
   opcode 1
 
 @ Skip next sample
-async command SignalGen_Skip \
+async command Skip \
   opcode 2
 
+enum DpReqType {
+    IMMEDIATE
+    ASYNC
+}
+
+
 @ Signal Generator Settings
-async command SignalGen_Dp(
-                                  records: U32
-                                ) \
+async command Dp(
+                   reqType: DpReqType
+                   records: U32
+                   $priority: U32
+                  ) \
   opcode 3
 

Ref/SignalGen/Events.fppi

@@ -1,5 +1,5 @@
 @ Signal Generator Settings Changed
-event SignalGen_SettingsChanged(
+event SettingsChanged(
                                  Frequency: U32
                                  Amplitude: F32
                                  Phase: F32
@@ -9,30 +9,54 @@ event SignalGen_SettingsChanged(
   id 0 \
   format "Set Frequency(Hz) {}, Amplitude {f}, Phase {f}, Signal Type {}"
 
-event SignalGen_DpStarted(
+event DpStarted(
                                  records: U32
                                ) \
   severity activity low \
   id 1 \
   format "Writing {} DP records"
 
-event SignalGen_DpComplete(
+event DpComplete(
                                  records: U32
                                  bytes: U32
                                ) \
   severity activity low \
   id 2 \
   format "Writing {} DP records {} bytes total"
 
-event SignalGen_DpRecordFull(
+event DpRecordFull(
                                  records: U32
                                  bytes: U32
                                ) \
   severity warning low \
   id 3 \
   format "DP container full with {} records and {} bytes. Closing DP."
 
-event SignalGen_DpsNotConnected \
+event DpsNotConnected \
   severity warning high \
   id 4 \
   format "DP Ports not connected!"
+
+event DpMemoryFail \
+  severity warning high \
+  id 5 \
+  format "Failed to acquire a DP buffer"
+
+event InSufficientDpRecords \
+  severity warning high \
+  id 6 \
+  format "Need to request at least one record"
+
+event DpMemRequested(
+                                 $size: U32
+                               ) \
+  severity activity low \
+  id 7 \
+  format "Requesting {} bytes for DP"
+
+event DpMemReceived(
+                                 $size: U32
+                               ) \
+  severity activity low \
+  id 8 \
+  format "Received {} bytes for DP"

Ref/SignalGen/SignalGen.cpp

@@ -41,7 +41,8 @@ namespace Ref {
         skipOne(false),
         m_dpInProgress(false),
         m_numDps(0),
-        m_currDp(0)
+        m_currDp(0),
+        m_dpPriority(0)
     {}
 
 
@@ -134,15 +135,22 @@ namespace Ref {
 
         // if a Data product is being generated, store a record
         if (this->m_dpInProgress) {
+            // printf("DP1: %u %u %lu %u\n",
+            //     this->m_dpContainer.getBuffer().getSize(),
+            //     SignalInfo::SERIALIZED_SIZE,
+            //     this->m_dpContainer.getDataSize(),
+            //     this->m_dpContainer.getBuffer().getSerializeRepr().getBuffLeft()
+            //     );
             Fw::SerializeStatus stat = this->m_dpContainer.serializeRecord_DataRecord(sigInfo);
             this->m_currDp++;
             this->m_dpBytes += SignalInfo::SERIALIZED_SIZE;
+            // printf("DP2: %u %u %lu\n",this->m_dpContainer.getBuffer().getSize(),this->m_dpBytes,this->m_dpContainer.getDataSize());
             // check for full data product
             if (Fw::SerializeStatus::FW_SERIALIZE_NO_ROOM_LEFT == stat) {
-                this->log_WARNING_LO_SignalGen_DpRecordFull(this->m_currDp,this->m_dpBytes);
+                this->log_WARNING_LO_DpRecordFull(this->m_currDp,this->m_dpBytes);
                 this->cleanupAndSendDp();
             } else if (this->m_currDp == this->m_numDps) { // if we reached the target number of DPs
-                this->log_ACTIVITY_LO_SignalGen_DpComplete(this->m_numDps,this->m_dpBytes);
+                this->log_ACTIVITY_LO_DpComplete(this->m_numDps,this->m_dpBytes);
                 this->cleanupAndSendDp();
             }
 
@@ -153,7 +161,7 @@ namespace Ref {
         this->ticks += 1;
     }
 
-    void SignalGen::SignalGen_Settings_cmdHandler(
+    void SignalGen::Settings_cmdHandler(
         FwOpcodeType opCode, /*!< The opcode*/
         U32 cmdSeq, /*!< The command sequence number*/
         U32 Frequency,
@@ -175,12 +183,12 @@ namespace Ref {
             this->sigPairHistory[i].settime(0.0f);
             this->sigPairHistory[i].setvalue(0.0f);
         }
-        this->log_ACTIVITY_LO_SignalGen_SettingsChanged(this->signalFrequency, this->signalAmplitude, this->signalPhase, this->sigType);
+        this->log_ACTIVITY_LO_SettingsChanged(this->signalFrequency, this->signalAmplitude, this->signalPhase, this->sigType);
         this->tlmWrite_Type(SigType);
         this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
     }
 
-    void SignalGen::SignalGen_Toggle_cmdHandler(
+    void SignalGen::Toggle_cmdHandler(
         FwOpcodeType opCode, /*!< The opcode*/
         U32 cmdSeq /*!< The command sequence number*/
     )
@@ -190,7 +198,7 @@ namespace Ref {
         this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
     }
 
-    void SignalGen::SignalGen_Skip_cmdHandler(
+    void SignalGen::Skip_cmdHandler(
         FwOpcodeType opCode, /*!< The opcode*/
         U32 cmdSeq /*!< The command sequence number*/
     )
@@ -199,34 +207,64 @@ namespace Ref {
         this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
     }
 
-    void SignalGen ::
-        SignalGen_Dp_cmdHandler(
-            FwOpcodeType opCode,
-            U32 cmdSeq,
-            U32 records
-        )
+    void SignalGen::Dp_cmdHandler(
+        FwOpcodeType opCode,
+        U32 cmdSeq,
+        Ref::SignalGen_DpReqType reqType,
+        U32 records,
+        U32 priority
+    )
     {
+        // at least one record
+        if (0 == records) {
+            this->log_WARNING_HI_InSufficientDpRecords();
+            this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::VALIDATION_ERROR);
+            return;
+        }
+
         // make sure DPs are available
         if (
             not this->isConnected_productGetOut_OutputPort(0)
         ) {
-            this->log_WARNING_HI_SignalGen_DpsNotConnected();
+            this->log_WARNING_HI_DpsNotConnected();
             this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::EXECUTION_ERROR);
             return;
         }
 
-        // get DP buffer
-        this->dpGet_DataContainer(records*SIZE_OF_DataRecord_RECORD,this->m_dpContainer);
-        this->m_dpInProgress = true;
+        // get DP buffer. Use sync or async request depending on 
+        // requested type
+        FwSizeType dpSize = records*(SignalInfo::SERIALIZED_SIZE + sizeof(FwDpIdType));
         this->m_numDps = records;
         this->m_currDp = 0;
-        this->log_ACTIVITY_LO_SignalGen_DpStarted(records);
-        this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
+        this->m_dpPriority = static_cast<FwDpPriorityType>(priority);
+        this->log_ACTIVITY_LO_DpMemRequested(dpSize);
+        if (Ref::SignalGen_DpReqType::IMMEDIATE ==  reqType) {
+            Fw::Success stat = this->dpGet_DataContainer(dpSize,this->m_dpContainer);
+            // make sure we got the memory we wanted
+            if (Fw::Success::FAILURE == stat) {
+                this->log_WARNING_HI_DpMemoryFail();
+                this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::EXECUTION_ERROR);
+            } else {
+                this->m_dpInProgress = true;
+                this->log_ACTIVITY_LO_DpStarted(records);
+                this->log_ACTIVITY_LO_DpMemReceived(this->m_dpContainer.getBuffer().getSize());
+                this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
+                // override priority with requested priority
+                this->m_dpContainer.setPriority(this->m_dpPriority);
+            }
+        } else if (Ref::SignalGen_DpReqType::ASYNC == reqType) {
+            this->dpRequest_DataContainer(dpSize);
+            this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
+        } else {
+            // should never get here
+            FW_ASSERT(0,reqType.e);
+        }
+
     }
 
     void SignalGen::cleanupAndSendDp() {
         this->dpSend(this->m_dpContainer);
-        this->m_dpInProgress = 0;
+        this->m_dpInProgress = false;
         this->m_dpBytes = 0;
         this->m_numDps = 0;
         this->m_currDp = 0;
@@ -244,8 +282,22 @@ namespace Ref {
             Fw::Success::T status
         )
     {
-        // TODO
-    }
 
+        // Make sure we got the buffer we wanted or quit
+        if (Fw::Success::SUCCESS == status) {
+            this->m_dpContainer = container;
+            this->m_dpInProgress = true;
+            // set previously requested priority
+            this->m_dpContainer.setPriority(this->m_dpPriority);
+            this->log_ACTIVITY_LO_DpStarted(this->m_numDps);
+        } else {
+            this->log_WARNING_HI_DpMemoryFail();
+            // cleanup
+            this->m_dpInProgress = false;
+            this->m_dpBytes = 0;
+            this->m_numDps = 0;
+            this->m_currDp = 0;
+        }
+    }
 
 };

Ref/SignalGen/SignalGen.hpp

@@ -31,9 +31,9 @@ namespace Ref {
         void schedIn_handler(
             NATIVE_INT_TYPE portNum, /*!< The port number*/
             U32 context /*!< The call order*/
-        );
+        ) final;
 
-        void SignalGen_Settings_cmdHandler(
+        void Settings_cmdHandler(
             FwOpcodeType opCode, /*!< The opcode*/
             U32 cmdSeq, /*!< The command sequence number*/
             U32 Frequency,
@@ -42,23 +42,26 @@ namespace Ref {
             Ref::SignalType SigType
         ) final;
 
-        void SignalGen_Toggle_cmdHandler(
+        void Toggle_cmdHandler(
             FwOpcodeType opCode, /*!< The opcode*/
             U32 cmdSeq /*!< The command sequence number*/
         ) final;
-        void SignalGen_Skip_cmdHandler(
+
+        void Skip_cmdHandler(
             FwOpcodeType opCode, /*!< The opcode*/
             U32 cmdSeq /*!< The command sequence number*/
         ) final;
 
         //! Handler implementation for command SignalGen_Dp
         //!
         //! Signal Generator Settings
-        void SignalGen_Dp_cmdHandler(
-            FwOpcodeType opCode, //!< The opcode
-            U32 cmdSeq, //!< The command sequence number
-            U32 records
-        ) final;
+        void Dp_cmdHandler(
+           FwOpcodeType opCode, //!< The opcode
+           U32 cmdSeq, //!< The command sequence number
+           Ref::SignalGen_DpReqType reqType,
+           U32 records,
+           U32 priority
+       ) final;
 
         // ----------------------------------------------------------------------
         // Handler implementations for data products
@@ -103,6 +106,11 @@ namespace Ref {
         U32 m_numDps; //!< number of DPs to store
         U32 m_currDp; //!< current DP number
         U32 m_dpBytes; //!< currently serialized records
+        FwDpPriorityType m_dpPriority; //!< stored priority for current DP
+
+        // for async DP
+        FwOpcodeType m_opCode;
+        U32 m_cmdSeq;
 
     };
 };