change PLOC/MPSOC code to using new SP code

mission/controller/AcsController.cpp

@@ -1,9 +1,9 @@
-#include <fsfw/datapool/PoolReadGuard.h>
 #include "AcsController.h"
 
+#include <fsfw/datapool/PoolReadGuard.h>
+
 AcsController::AcsController(object_id_t objectId)
-    : ExtendedControllerBase(objectId, objects::NO_OBJECT),
-      mgmData(this) {}
+    : ExtendedControllerBase(objectId, objects::NO_OBJECT), mgmData(this) {}
 
 ReturnValue_t AcsController::handleCommandMessage(CommandMessage *message) {
   return HasReturnvaluesIF::RETURN_OK;
@@ -30,8 +30,8 @@ void AcsController::performControlOperation() {
   }
 
   if (mgmData.read() == RETURN_OK) {
-      copyMgmData();
-      mgmData.commit();
+    copyMgmData();
+    mgmData.commit();
   }
 }
 
@@ -56,31 +56,31 @@ ReturnValue_t AcsController::checkModeCommand(Mode_t mode, Submode_t submode,
 void AcsController::copyMgmData() {
   {
     PoolReadGuard pg(&mgm0Lis3Set);
-    if(pg.getReadResult() == RETURN_OK) {
+    if (pg.getReadResult() == RETURN_OK) {
       std::memcpy(mgmData.mgm0Lis3.value, mgm0Lis3Set.fieldStrengths.value, 3 * sizeof(float));
     }
   }
   {
     PoolReadGuard pg(&mgm1Rm3100Set);
-    if(pg.getReadResult() == RETURN_OK) {
+    if (pg.getReadResult() == RETURN_OK) {
       std::memcpy(mgmData.mgm1Rm3100.value, mgm1Rm3100Set.fieldStrengths.value, 3 * sizeof(float));
     }
   }
   {
     PoolReadGuard pg(&mgm2Lis3Set);
-    if(pg.getReadResult() == RETURN_OK) {
+    if (pg.getReadResult() == RETURN_OK) {
       std::memcpy(mgmData.mgm2Lis3.value, mgm2Lis3Set.fieldStrengths.value, 3 * sizeof(float));
     }
   }
   {
     PoolReadGuard pg(&mgm3Rm3100Set);
-    if(pg.getReadResult() == RETURN_OK) {
+    if (pg.getReadResult() == RETURN_OK) {
       std::memcpy(mgmData.mgm3Rm3100.value, mgm3Rm3100Set.fieldStrengths.value, 3 * sizeof(float));
     }
   }
   {
     PoolReadGuard pg(&imtqMgmSet);
-    if(pg.getReadResult() == RETURN_OK) {
+    if (pg.getReadResult() == RETURN_OK) {
       std::memcpy(mgmData.imtqCal.value, imtqMgmSet.mgmXyz.value, 3 * sizeof(int32_t));
       mgmData.actuationCalStatus.value = imtqMgmSet.coilActuationStatus.value;
     }

mission/controller/AcsController.h

@@ -2,8 +2,9 @@
 #define MISSION_CONTROLLER_ACSCONTROLLER_H_
 
 #include <commonObjects.h>
-#include "controllerdefinitions/AcsCtrlDefinitions.h"
 #include <fsfw/controller/ExtendedControllerBase.h>
+
+#include "controllerdefinitions/AcsCtrlDefinitions.h"
 #include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
 #include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
 #include "mission/devices/devicedefinitions/IMTQHandlerDefinitions.h"
@@ -33,11 +34,16 @@ class AcsController : public ExtendedControllerBase {
   // MGMs
   acsctrl::MgmData mgmData;
 
-  MGMLIS3MDL::MgmPrimaryDataset mgm0Lis3Set = MGMLIS3MDL::MgmPrimaryDataset(objects::MGM_0_LIS3_HANDLER);
-  RM3100::Rm3100PrimaryDataset mgm1Rm3100Set = RM3100::Rm3100PrimaryDataset(objects::MGM_1_RM3100_HANDLER);
-  MGMLIS3MDL::MgmPrimaryDataset mgm2Lis3Set = MGMLIS3MDL::MgmPrimaryDataset(objects::MGM_2_LIS3_HANDLER);
-  RM3100::Rm3100PrimaryDataset mgm3Rm3100Set = RM3100::Rm3100PrimaryDataset(objects::MGM_3_RM3100_HANDLER);
-  IMTQ::CalibratedMtmMeasurementSet imtqMgmSet = IMTQ::CalibratedMtmMeasurementSet(objects::IMTQ_HANDLER);
+  MGMLIS3MDL::MgmPrimaryDataset mgm0Lis3Set =
+      MGMLIS3MDL::MgmPrimaryDataset(objects::MGM_0_LIS3_HANDLER);
+  RM3100::Rm3100PrimaryDataset mgm1Rm3100Set =
+      RM3100::Rm3100PrimaryDataset(objects::MGM_1_RM3100_HANDLER);
+  MGMLIS3MDL::MgmPrimaryDataset mgm2Lis3Set =
+      MGMLIS3MDL::MgmPrimaryDataset(objects::MGM_2_LIS3_HANDLER);
+  RM3100::Rm3100PrimaryDataset mgm3Rm3100Set =
+      RM3100::Rm3100PrimaryDataset(objects::MGM_3_RM3100_HANDLER);
+  IMTQ::CalibratedMtmMeasurementSet imtqMgmSet =
+      IMTQ::CalibratedMtmMeasurementSet(objects::IMTQ_HANDLER);
 
   PoolEntry<float> mgm0PoolVec = PoolEntry<float>(3);
   PoolEntry<float> mgm1PoolVec = PoolEntry<float>(3);

mission/controller/controllerdefinitions/AcsCtrlDefinitions.h

@@ -1,15 +1,14 @@
 #ifndef MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCTRLDEFINITIONS_H_
 #define MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCTRLDEFINITIONS_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
+
 #include <cstdint>
 
 namespace acsctrl {
 
-enum SetIds : uint32_t {
-  MGM_SENSOR_DATA
-};
+enum SetIds : uint32_t { MGM_SENSOR_DATA };
 
 enum PoolIds : lp_id_t {
   MGM_0_LIS3_UT,
@@ -20,14 +19,13 @@ enum PoolIds : lp_id_t {
   MGM_IMTQ_CAL_ACT_STATUS
 };
 
-
 static constexpr uint8_t MGM_SET_ENTRIES = 5;
 
 /**
  * @brief   This dataset can be used to store the collected temperatures of all temperature sensors
  */
 class MgmData : public StaticLocalDataSet<MGM_SET_ENTRIES> {
-public:
+ public:
   MgmData(HasLocalDataPoolIF* hkOwner) : StaticLocalDataSet(hkOwner, MGM_SENSOR_DATA) {}
 
   // The ACS board measurement are in floating point uT
@@ -37,12 +35,12 @@ public:
   lp_vec_t<float, 3> mgm3Rm3100 = lp_vec_t<float, 3>(sid.objectId, MGM_3_RM3100_UT, this);
   // The IMTQ measurements are in integer nT
   lp_vec_t<int32_t, 3> imtqCal = lp_vec_t<int32_t, 3>(sid.objectId, MGM_IMTQ_CAL_NT, this);
-  lp_var_t<uint8_t> actuationCalStatus = lp_var_t<uint8_t>(sid.objectId,
-      MGM_IMTQ_CAL_ACT_STATUS, this);
-private:
+  lp_var_t<uint8_t> actuationCalStatus =
+      lp_var_t<uint8_t>(sid.objectId, MGM_IMTQ_CAL_ACT_STATUS, this);
 
+ private:
 };
 
-}
+}  // namespace acsctrl
 
 #endif /* MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCTRLDEFINITIONS_H_ */

mission/core/GenericFactory.cpp

@@ -91,14 +91,17 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_) {
                            pus::PUS_SERVICE_2, 3, 10);
   new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, apid::EIVE_OBSW,
                            pus::PUS_SERVICE_3);
-  new Service5EventReporting(PsbParams(objects::PUS_SERVICE_5_EVENT_REPORTING, apid::EIVE_OBSW,
-                             pus::PUS_SERVICE_5), 15, 45);
+  new Service5EventReporting(
+      PsbParams(objects::PUS_SERVICE_5_EVENT_REPORTING, apid::EIVE_OBSW, pus::PUS_SERVICE_5), 15,
+      45);
   new Service8FunctionManagement(objects::PUS_SERVICE_8_FUNCTION_MGMT, apid::EIVE_OBSW,
                                  pus::PUS_SERVICE_8, 3, 60);
-  new Service9TimeManagement(PsbParams(objects::PUS_SERVICE_9_TIME_MGMT, apid::EIVE_OBSW, pus::PUS_SERVICE_9));
+  new Service9TimeManagement(
+      PsbParams(objects::PUS_SERVICE_9_TIME_MGMT, apid::EIVE_OBSW, pus::PUS_SERVICE_9));
 
   new Service11TelecommandScheduling<common::OBSW_MAX_SCHEDULED_TCS>(
-      PsbParams(objects::PUS_SERVICE_11_TC_SCHEDULER, apid::EIVE_OBSW, pus::PUS_SERVICE_11), ccsdsDistrib);
+      PsbParams(objects::PUS_SERVICE_11_TC_SCHEDULER, apid::EIVE_OBSW, pus::PUS_SERVICE_11),
+      ccsdsDistrib);
   new Service17Test(PsbParams(objects::PUS_SERVICE_17_TEST, apid::EIVE_OBSW, pus::PUS_SERVICE_17));
   new Service20ParameterManagement(objects::PUS_SERVICE_20_PARAMETERS, apid::EIVE_OBSW,
                                    pus::PUS_SERVICE_20);

mission/devices/IMTQHandler.cpp

@@ -753,13 +753,13 @@ void IMTQHandler::fillCalibratedMtmDataset(const uint8_t* packet) {
   calMtmMeasurementSet.setValidity(true, true);
   int8_t offset = 2;
   calMtmMeasurementSet.mgmXyz[0] = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16 |
-                                *(packet + offset + 1) << 8 | *(packet + offset);
+                                   *(packet + offset + 1) << 8 | *(packet + offset);
   offset += 4;
   calMtmMeasurementSet.mgmXyz[1] = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16 |
-                                *(packet + offset + 1) << 8 | *(packet + offset);
+                                   *(packet + offset + 1) << 8 | *(packet + offset);
   offset += 4;
   calMtmMeasurementSet.mgmXyz[2] = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16 |
-                                *(packet + offset + 1) << 8 | *(packet + offset);
+                                   *(packet + offset + 1) << 8 | *(packet + offset);
   offset += 4;
   calMtmMeasurementSet.coilActuationStatus = (*(packet + offset + 3) << 24) |
                                              (*(packet + offset + 2) << 16) |

mission/devices/PCDUHandler.h

@@ -30,8 +30,7 @@ class PCDUHandler : public PowerSwitchIF,
 
   virtual ReturnValue_t initialize() override;
   virtual ReturnValue_t performOperation(uint8_t counter) override;
-  virtual void handleChangedDataset(sid_t sid,
-                                    store_address_t storeId = store_address_t::invalid(),
+  virtual void handleChangedDataset(sid_t sid, store_address_t storeId = store_address_t::invalid(),
                                     bool* clearMessage = nullptr) override;
 
   virtual ReturnValue_t sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) override;

mission/devices/devicedefinitions/SpBase.h

@@ -0,0 +1,83 @@
+#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_SPBASE_H_
+#define MISSION_DEVICES_DEVICEDEFINITIONS_SPBASE_H_
+
+#include <fsfw/tmtcpacket/ccsds/SpacePacketCreator.h>
+
+#include <cstdint>
+
+struct SpBaseParams {
+  SpBaseParams(SpacePacketCreator& creator) : creator(creator) {}
+
+  SpBaseParams(SpacePacketCreator& creator, uint8_t* buf, size_t maxSize)
+      : creator(creator), buf(buf), maxSize(maxSize) {}
+
+  void setPayloadLen(size_t payloadLen_) { dataFieldLen = payloadLen_ + 2; }
+
+  void setDataFieldLen(size_t dataFieldLen_) { dataFieldLen = dataFieldLen_; }
+
+  SpacePacketCreator& creator;
+  uint8_t* buf = nullptr;
+  size_t maxSize = 0;
+  size_t dataFieldLen = 0;
+};
+
+class SpacePacketBase {
+ public:
+  SpacePacketBase(SpBaseParams params) : spParams(params) { updateFields(); }
+
+  SpacePacketBase(SpBaseParams params, uint16_t apid, uint16_t seqCount) : spParams(params) {
+    spParams.creator.setApid(apid);
+    spParams.creator.setSeqCount(seqCount);
+    updateFields();
+  }
+
+  void updateFields() {
+    payloadStart = spParams.buf + ccsds::HEADER_LEN;
+    spParams.creator.setDataLen(spParams.dataFieldLen - 1);
+    spParams.creator.setPacketType(ccsds::PacketType::TC);
+  }
+
+  const uint8_t* getFullPacket() const { return spParams.buf; }
+
+  size_t getFullPacketLen() const { return spParams.creator.getFullPacketLen(); }
+
+  uint16_t getApid() const { return spParams.creator.getApid(); }
+
+  ReturnValue_t checkPayloadLen() {
+    if (ccsds::HEADER_LEN + spParams.dataFieldLen > spParams.maxSize) {
+      return SerializeIF::BUFFER_TOO_SHORT;
+    }
+
+    return result::OK;
+  }
+
+  ReturnValue_t serializeHeader() {
+    updateFields();
+    size_t serLen = 0;
+    return spParams.creator.serializeBe(spParams.buf, serLen, spParams.maxSize);
+  }
+
+  ReturnValue_t checkSizeAndSerializeHeader() {
+    ReturnValue_t result = checkPayloadLen();
+    if (result != result::OK) {
+      return result;
+    }
+    return serializeHeader();
+  }
+
+  ReturnValue_t calcCrc() {
+    /* Calculate crc */
+    uint16_t crc = CRC::crc16ccitt(spParams.buf, ccsds::HEADER_LEN + spParams.dataFieldLen - 2);
+
+    /* Add crc to packet data field of space packet */
+    size_t serializedSize = 0;
+    return SerializeAdapter::serialize<uint16_t>(&crc, &payloadStart, &serializedSize, sizeof(crc),
+                                                 SerializeIF::Endianness::BIG);
+  }
+
+ protected:
+  SpBaseParams spParams;
+  uint8_t* payloadStart;
+};
+
+#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_SPBASE_H_ */

mission/tmtc/TmFunnel.cpp

@@ -11,8 +11,11 @@ object_id_t TmFunnel::downlinkDestination = objects::NO_OBJECT;
 object_id_t TmFunnel::storageDestination = objects::NO_OBJECT;
 
 TmFunnel::TmFunnel(object_id_t objectId, CdsShortTimeStamper& timeReader, uint32_t messageDepth,
-    uint8_t reportReceptionVc)
-    : SystemObject(objectId), timeReader(timeReader), messageDepth(messageDepth), reportReceptionVc(reportReceptionVc) {
+                   uint8_t reportReceptionVc)
+    : SystemObject(objectId),
+      timeReader(timeReader),
+      messageDepth(messageDepth),
+      reportReceptionVc(reportReceptionVc) {
   auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
   tmQueue = QueueFactory::instance()->createMessageQueue(
       messageDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
@@ -54,14 +57,13 @@ ReturnValue_t TmFunnel::handlePacket(TmTcMessage* message) {
 
   PusTmZeroCopyWriter packet(timeReader, packetData, size);
   result = packet.parseDataWithoutCrcCheck();
-  if(result != HasReturnvaluesIF::RETURN_OK) {
+  if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   packet.setSequenceCount(sourceSequenceCount++);
   sourceSequenceCount = sourceSequenceCount % ccsds::LIMIT_SEQUENCE_COUNT;
   packet.updateErrorControl();
 
-
   result = tmQueue->sendToDefault(message);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     tmStore->deleteData(message->getStorageId());

mission/tmtc/TmFunnel.h

@@ -24,7 +24,8 @@ class TmFunnel : public AcceptsTelemetryIF, public ExecutableObjectIF, public Sy
   friend void(Factory::setStaticFrameworkObjectIds)();
 
  public:
-  TmFunnel(object_id_t objectId, CdsShortTimeStamper& timeReader, uint32_t messageDepth = 20, uint8_t reportReceptionVc = 0);
+  TmFunnel(object_id_t objectId, CdsShortTimeStamper& timeReader, uint32_t messageDepth = 20,
+           uint8_t reportReceptionVc = 0);
   virtual ~TmFunnel();
 
   virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) override;