Svc.ComAggregator: consolidate idle filling and configuration

Svc/Ccsds/CcsdsSdlsFramer/CcsdsSdlsFramer.cpp

@@ -7,11 +7,15 @@
 #include "Svc/Ccsds/CcsdsSdlsFramer/CcsdsSdlsFramer.hpp"
 
 #include <Fw/Prm/ParamValid.hpp>
+#include "Svc/Ccsds/Types/FppConstantsAc.hpp"
 
 namespace Svc {
 
 namespace Ccsds {
 
+static_assert(sizeof(decltype(ComCfg::FrameContext().get_saIndex())) == SdlsSaIndexSize,
+              "Svc.Ccsds.SdlsSaIndexSize must match the prepended SA index");
+
 // ----------------------------------------------------------------------
 // Component construction and destruction
 // ----------------------------------------------------------------------

Svc/Ccsds/SpacePacketFramer/docs/sdd.md

@@ -4,7 +4,7 @@ The `Svc::Ccsds::SpacePacketFramer` is an implementation of the [FramerInterface
 
 It receives user data on its input port and constructs a CCSDS Space Packet. Please refer to the CCSDS [Space Packet Protocol specification (CCSDS 133.0-B-2)](https://ccsds.org/Pubs/133x0b2e2.pdf) for details on the packet format.
 
-The `Svc::Ccsds::SpacePacketFramer` is typically used upstream of a component that adds transfer frame headers, such as the `Svc::Ccsds::TmFramer`. It encapsulates user data into a Space Packet, adding the necessary header fields.
+The `Svc::Ccsds::SpacePacketFramer` is typically used upstream of `Svc::ComAggregator`, which packs Space Packets into fixed-size, idle-filled aggregates for a component that adds transfer frame headers, such as the `Svc::Ccsds::TmFramer`. It encapsulates user data into a Space Packet, adding the necessary header fields.
 
 ## Configuration
 The `Svc::Ccsds::SpacePacketFramer` requires an Application Process Identifier (APID) for the Space Packets it generates. This APID is typically provided during instantiation or configuration. It also uses a sequence count, which is managed per APID via the `getApidSeqCount` port.

Svc/Ccsds/TmFramer/TmFramer.cpp

@@ -6,7 +6,6 @@
 
 #include "Svc/Ccsds/TmFramer/TmFramer.hpp"
 #include "Svc/Ccsds/Utils/CRC16.hpp"
-#include "Svc/Ccsds/Utils/IdlePacket.hpp"
 #include "config/FppConstantsAc.hpp"
 
 namespace Svc {
@@ -27,10 +26,8 @@ TmFramer ::~TmFramer() {}
 // ----------------------------------------------------------------------
 
 void TmFramer ::dataIn_handler(FwIndexType portNum, Fw::Buffer& data, const ComCfg::FrameContext& context) {
-    FW_ASSERT(data.getSize() <= TmPayloadCapacity, static_cast<FwAssertArgType>(data.getSize()));
-    // The data must either fill the data field exactly or leave room for a minimum idle packet (4.2.2.5)
-    const FwSizeType residual = TmPayloadCapacity - data.getSize();
-    FW_ASSERT(residual == 0 || residual >= Utils::IdlePacket::MIN_SIZE, static_cast<FwAssertArgType>(residual));
+    // The data must fill the data field exactly: idle filling (Standard 4.2.2.5) is done upstream by Svc::ComAggregator
+    FW_ASSERT(data.getSize() == TmPayloadCapacity, static_cast<FwAssertArgType>(data.getSize()));
     FW_ASSERT(context.get_firstHeaderPointer() <= TMSubfields::fhpMask,
               static_cast<FwAssertArgType>(context.get_firstHeaderPointer()));
     FW_ASSERT(this->m_bufferState == BufferOwnershipState::OWNED, static_cast<FwAssertArgType>(this->m_bufferState));
@@ -74,12 +71,6 @@ void TmFramer ::dataIn_handler(FwIndexType portNum, Fw::Buffer& data, const ComC
     status = frameSerializer.serializeFrom(data.getData(), data.getSize(), Fw::Serialization::OMIT_LENGTH);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
 
-    // As per TM Standard 4.2.2.5, fill the rest of the data field with an Idle Packet.
-    // A full data field (e.g. delivered by a spanning aggregator) requires no fill.
-    if (residual > 0) {
-        this->fill_with_idle_packet(frameSerializer);
-    }
-
     // -------------------------------------------------
     // Trailer (CRC)
     // -------------------------------------------------
@@ -114,18 +105,5 @@ void TmFramer ::dataReturnIn_handler(FwIndexType portNum,
     FW_ASSERT(frameBuffer.getData() < &this->m_frameBuffer[0] + sizeof(this->m_frameBuffer));
     this->m_bufferState = BufferOwnershipState::OWNED;
 }
-
-void TmFramer ::fill_with_idle_packet(Fw::SerialBufferBase& serializer) {
-    constexpr FwSizeType endIndex = ComCfg::TmFrameFixedSize - TMTrailer::SERIALIZED_SIZE;
-    const FwSizeType startIndex = serializer.getSize();
-    FW_ASSERT(startIndex <= endIndex, static_cast<FwAssertArgType>(startIndex));
-    const FwSizeType idlePacketSize = endIndex - startIndex;
-
-    FW_ASSERT(idlePacketSize >= Utils::IdlePacket::MIN_SIZE, static_cast<FwAssertArgType>(idlePacketSize));
-    FW_ASSERT(idlePacketSize <= ComCfg::TmFrameFixedSize, static_cast<FwAssertArgType>(idlePacketSize));
-
-    const Fw::SerializeStatus status = Utils::IdlePacket::serialize(serializer, idlePacketSize);
-    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
-}
 }  // namespace Ccsds
 }  // namespace Svc

Svc/Ccsds/TmFramer/TmFramer.hpp

@@ -9,7 +9,6 @@
 
 #include "Svc/Ccsds/TmFramer/TmFramerComponentAc.hpp"
 #include "Svc/Ccsds/Types/FppConstantsAc.hpp"
-#include "Svc/Ccsds/Types/SpacePacketHeaderSerializableAc.hpp"
 #include "Svc/Ccsds/Types/TMHeaderSerializableAc.hpp"
 #include "Svc/Ccsds/Types/TMTrailerSerializableAc.hpp"
 
@@ -23,21 +22,13 @@ class TmFramer final : public TmFramerComponentBase {
     static_assert(ComCfg::TmFrameFixedSize > TMHeader::SERIALIZED_SIZE + TMTrailer::SERIALIZED_SIZE,
                   "TM Frame Fixed Size must be at least large enough to hold header, trailer and data");
 
-    static constexpr FwSizeType TmPayloadCapacity =
-        ComCfg::TmFrameFixedSize - (TMHeader::SERIALIZED_SIZE + TMTrailer::SERIALIZED_SIZE);
-    static constexpr FwSizeType SppOverhead = (2 * SpacePacketHeader::SERIALIZED_SIZE) + 1;
+    static_assert(static_cast<FwSizeType>(TMHeader::SERIALIZED_SIZE) == static_cast<FwSizeType>(TmHeaderSize),
+                  "Svc.Ccsds.TmHeaderSize must match TMHeader");
+    static_assert(static_cast<FwSizeType>(TMTrailer::SERIALIZED_SIZE) == static_cast<FwSizeType>(TmTrailerSize),
+                  "Svc.Ccsds.TmTrailerSize must match TMTrailer");
 
-    // These are to ensure the frame can hold the packet buffer, its SP header and an idle packet of 1 byte
-    // This is because TM specifies a frame to be padded with an idle packet of at least 1 byte of idle data
-    static_assert(TmPayloadCapacity >= FW_COM_BUFFER_MAX_SIZE + SppOverhead,
-                  "TM Frame Fixed Size must be at least large enough to hold Tm Header + Footer, a full com buffer, 2 "
-                  "SP headers, and 1 idle byte");
-    static_assert(TmPayloadCapacity >= FW_FILE_BUFFER_MAX_SIZE + SppOverhead,
-                  "TM Frame Fixed Size must be at least large enough to hold Tm Header + Footer, a full file buffer, 2 "
-                  "SP headers, and 1 idle byte");
-
-    static_assert(static_cast<FwSizeType>(ComCfg::AggregationSize) <= TmPayloadCapacity,
-                  "ComCfg::AggregationSize must fit in the TM data field");
+    //! Size of the frame data field: every dataIn payload must be exactly this size
+    static constexpr FwSizeType TmPayloadCapacity = static_cast<FwSizeType>(TmDataFieldSize);
 
     enum class BufferOwnershipState {
         NOT_OWNED,  //!< The buffer is currently not owned by the TmFramer
@@ -71,9 +62,9 @@ class TmFramer final : public TmFramerComponentBase {
 
     //! Handler implementation for dataIn
     //!
-    //! Port to receive data to frame, in a Fw::Buffer with optional context.
-    //! This is essentially the CCSDS TM VCP.request Service Primitive, with
-    //! Packet=data and GVCID implicitly passed in context (TM Protocol 3.3.3.2)
+    //! Port to receive a complete frame data field to frame, in a Fw::Buffer with optional context.
+    //! The buffer must be exactly TmPayloadCapacity bytes (idle-filled upstream, e.g. by Svc::ComAggregator);
+    //! any other size asserts. GVCID and the First Header Pointer are passed in the context.
     //!
     void dataIn_handler(FwIndexType portNum,  //!< The port number
                         Fw::Buffer& data,
@@ -86,15 +77,6 @@ class TmFramer final : public TmFramerComponentBase {
                               Fw::Buffer& data,
                               const ComCfg::FrameContext& context) override;
 
-    // ----------------------------------------------------------------------
-    // Helpers
-    // ----------------------------------------------------------------------
-  private:
-    //! Fill the frame buffer with an Idle Packet to complete the frame data field
-    //! as per CCSDS TM Protocol paragraph 4.2.2.5. Idle packet is inserted at the
-    //! start_index index of the frame buffer, and fills it up to the end minus CRC
-    void fill_with_idle_packet(Fw::SerialBufferBase& serializer);
-
     // ----------------------------------------------------------------------
     // Members
     // ----------------------------------------------------------------------

Svc/Ccsds/TmFramer/docs/sdd.md

@@ -2,24 +2,21 @@
 
 The `Svc::Ccsds::TmFramer` is an implementation of the [FramerInterface](../../../Interfaces/docs/sdd.md) for the CCSDS [TM Space Data Link Protocol](https://ccsds.org/Pubs/132x0b3.pdf). 
 
-It receives payload data (such as a Space Packet or a VCA_SDU) on input and produces a TM frame on its output port as a result. Please refer to the CCSDS [TM specification (CCSDS 132.0-B-3)](https://ccsds.org/Pubs/132x0b3.pdf) for details on the frame format and protocol.
+It receives a complete TM Transfer Frame Data Field (`Svc.Ccsds.TmDataFieldSize` bytes, produced by an upstream [`Svc::ComAggregator`](../../../ComAggregator/docs/sdd.md)) on input and produces a TM frame on its output port as a result. Please refer to the CCSDS [TM specification (CCSDS 132.0-B-3)](https://ccsds.org/Pubs/132x0b3.pdf) for details on the frame format and protocol.
 
-The `Svc::Ccsds::TmFramer` is designed to work in the common F Prime telemetry stack, receiving data from an upstream [`Svc::ComQueue`](../../../ComQueue/docs/sdd.md) and passing frames to a [Communications Adapter](../../../Interfaces/docs/sdd.md), such as a Radio manager component or [`Svc::ComStub`](../../../ComStub/docs/sdd.md), for transmission on the wire. It is commonly coupled with the [`Svc::Ccsds::SpacePacketFramer`](../../SpacePacketFramer/docs/sdd.md) to wrap CCSDS Space Packets into TM frames.
+The `Svc::Ccsds::TmFramer` is designed to work in the common F Prime telemetry stack, receiving complete, idle-filled data fields from an upstream [`Svc::ComAggregator`](../../../ComAggregator/docs/sdd.md) and passing frames to a [Communications Adapter](../../../Interfaces/docs/sdd.md), such as a Radio manager component or [`Svc::ComStub`](../../../ComStub/docs/sdd.md), for transmission on the wire. It is commonly coupled with the [`Svc::Ccsds::SpacePacketFramer`](../../SpacePacketFramer/docs/sdd.md) to wrap CCSDS Space Packets into TM frames.
 
 ## Internals
 
 The TM protocol specifies a fixed frame size. This can be configured in the `config/ComCfg.fpp` file.
 
 The `Svc::Ccsds::TmFramer` uses an internal (member) buffer to hold the fixed size frame. The buffer **must** be returned to the TmFramer via the `dataReturnIn` port once it has been used or consumed. When the buffer returns to the TmFramer it will reuse the buffer for the next frame. Should a component want to use the frame data past the time it is returned to the TmFramer, data should be copied before the original buffer is returned to the TmFramer via the `dataReturnIn` port. 
 
-The static sizing checks enforce that `ComCfg::AggregationSize` fits in the TM data field. The residual rule is
-enforced at runtime in `dataIn_handler`, deterministically on the first frame if the configuration is misconfigured.
-
-The data received on `dataIn` must either fill the frame data field exactly (e.g. when delivered by `Svc::ComAggregator` with packet spanning enabled) or leave at least 7 bytes (a Space Packet header plus one byte of idle data) so that the remainder can be filled with an Idle Packet as required by the protocol (4.2.2.5). Any other size is rejected by assertion. `ComCfg::AggregationSize` is the full TM data field available to `Svc::ComAggregator`; with spanning disabled, the maximum aggregate is `ComCfg::AggregationSize - 7`, while spanning-enabled aggregates fill the field exactly. Any intermediate layer that adds bytes (e.g. the 2-byte SA index of `Svc::Ccsds::CcsdsSdlsFramer`) must be subtracted from `ComCfg::AggregationSize` by the project.
+The `Svc::Ccsds::TmFramer` is a pure frame layer: the data received on `dataIn` must fill the frame data field exactly (`Svc.Ccsds.TmDataFieldSize`, i.e. `ComCfg.TmFrameFixedSize` minus the 6-byte primary header and 2-byte trailer) and is copied into the frame unchanged. Any other size is rejected by assertion, deterministically on the first frame when the upstream stack is misconfigured. Idle filling of the data field (protocol 4.2.2.5) is the responsibility of the upstream [`Svc::ComAggregator`](../../../ComAggregator/docs/sdd.md), which emits aggregates of exactly its configured size; this keeps idle data upstream of any layer inserted between the aggregator and the framer, such as `Svc::Ccsds::CcsdsSdlsFramer`, whose added bytes (`Svc.Ccsds.SdlsSaIndexSize`) the project subtracts from the aggregation size.
 
 ## Usage Examples
 
-The `Svc::Ccsds::TmFramer` component, as well as the rest of the CCSDS communications stack, is used in the [`Ref/`](https://github.com/nasa/fprime/tree/devel/Ref) example application. It is also generated by the `fprime-util new --deployment` command.
+The `Svc::Ccsds::TmFramer` component, as well as the rest of the CCSDS communications stack, is used in the [`Ref/`](https://github.com/nasa/fprime/tree/devel/TestDeploymentsProject/Ref) example application. It is also generated by the `fprime-util new --deployment` command.
 
 ## CCSDS Header Fields
 
@@ -57,7 +54,7 @@ For each frame generated, the `Svc::Ccsds::TmFramer` will populate the CCSDS TM
 | SVC-Ccsds-TM-FRAMER-001 | The TmFramer shall implement the `Svc.FramerInterface`. | Inspection, Unit Test |
 | SVC-Ccsds-TM-FRAMER-002 | The TmFramer shall construct CCSDS Telemetry (TM) Transfer Frames compliant with the CCSDS 132.0-B-3 standard. | Unit Test, Inspection |
 | SVC-Ccsds-TM-FRAMER-002 | The TmFramer shall use a fixed frame size that is configurable by the project. | Unit Test, Inspection |
-| SVC-Ccsds-TM-FRAMER-003 | The TmFramer shall accept payload data (Space Packets or VCA_SDU) to be framed via its `dataIn` port. | Unit Test |
+| SVC-Ccsds-TM-FRAMER-003 | The TmFramer shall accept a complete frame data field of exactly `Svc.Ccsds.TmDataFieldSize` bytes to be framed via its `dataIn` port, and shall assert on any other size. | Unit Test |
 | SVC-Ccsds-TM-FRAMER-004 | The TmFramer shall output the constructed TM Transfer Frame via its `dataOut` port. | Unit Test |
 | SVC-Ccsds-TM-FRAMER-005 | The TmFramer shall return ownership of the input buffer via the `dataReturnOut` port after the framing process is complete. | Unit Test |
 | SVC-Ccsds-TM-FRAMER-006 | The TmFramer shall accept returned buffers (previously sent via `dataOut`) through the `dataReturnIn` port for deallocation or reuse. | Unit Test |
@@ -67,6 +64,6 @@ For each frame generated, the `Svc::Ccsds::TmFramer` will populate the CCSDS TM
 | SVC-Ccsds-TM-FRAMER-010 | The TmFramer shall be configurable with a Spacecraft Identifier. | Inspection, Unit Test |
 | SVC-Ccsds-TM-FRAMER-011 | The TmFramer shall use the Virtual Channel Identifier passed in the `context` object on `dataIn`. | Unit Test |
 | SVC-Ccsds-TM-FRAMER-012 | The TmFramer shall manage Master Channel Frame Count and Virtual Channel Frame Count. | Unit Test |
-| SVC-Ccsds-TM-FRAMER-013 | The TmFramer shall fill the data field of the TM Transfer Frame with the payload data received on `dataIn`, and fill up the rest of the fixed-size frame with a single Idle Packet as defined by the protocol. When the payload data fills the data field exactly, no Idle Packet shall be inserted. | Unit Test |
-| SVC-Ccsds-TM-FRAMER-014 | The TmFramer shall assert that payload data received on `dataIn` either fills the data field exactly or leaves room for a minimum Idle Packet (header plus one byte). | Unit Test |
+| SVC-Ccsds-TM-FRAMER-013 | The TmFramer shall fill the data field of the TM Transfer Frame with the payload data received on `dataIn`, unchanged. | Unit Test |
+| SVC-Ccsds-TM-FRAMER-014 | The TmFramer shall assert that payload data received on `dataIn` fills the data field exactly. | Unit Test |
 | SVC-Ccsds-TM-FRAMER-015 | The TmFramer shall assert that the First Header Pointer received in the `dataIn` context fits within the 11-bit First Header Pointer field. | Unit Test |

Svc/Ccsds/TmFramer/test/ut/TmFramerTestMain.cpp

@@ -41,14 +41,9 @@ TEST(TmFramer, testFirstHeaderPointerFromContext) {
     tester.testFirstHeaderPointerFromContext();
 }
 
-TEST(TmFramer, testResidualTooSmallForIdlePacket) {
+TEST(TmFramer, testPartialDataFieldAsserts) {
     Svc::Ccsds::TmFramerTester tester;
-    tester.testResidualTooSmallForIdlePacket();
-}
-
-TEST(TmFramer, testFullDataFieldNoIdleFill) {
-    Svc::Ccsds::TmFramerTester tester;
-    tester.testFullDataFieldNoIdleFill();
+    tester.testPartialDataFieldAsserts();
 }
 
 int main(int argc, char** argv) {