eive-obsw/mission/tmtc/TmStoreTaskBase.cpp

#include "TmStoreTaskBase.h"

#include <fsfw/ipc/CommandMessageIF.h>
#include <fsfw/tasks/TaskFactory.h>
#include <fsfw/timemanager/Stopwatch.h>
#include <fsfw/tmstorage/TmStoreMessage.h>

#include "mission/persistentTmStoreDefs.h"

TmStoreTaskBase::TmStoreTaskBase(object_id_t objectId, StorageManagerIF& ipcStore,
                                 VirtualChannel& channel, SdCardMountedIF& sdcMan)
    : SystemObject(objectId), ipcStore(ipcStore), channel(channel), sdcMan(sdcMan) {}

bool TmStoreTaskBase::handleOneStore(PersistentTmStoreWithTmQueue& store,
                                     DumpContext& dumpContext) {
  ReturnValue_t result;
  bool tmToStoreReceived = false;
  bool tcRequestReceived = false;
  bool dumpPerformed = false;
  fileHasSwapped = false;
  dumpContext.packetWasDumped = false;
  dumpContext.vcBusyDuringDump = false;

  // Store TM persistently
  result = store.handleNextTm();
  if (result == returnvalue::OK) {
    tmToStoreReceived = true;
  }
  // Dump TMs when applicable
  if (store.getState() == PersistentTmStore::State::DUMPING) {
    if (handleOneDump(store, dumpContext, dumpPerformed) != returnvalue::OK) {
      return result;
    }
  } else {
    Command_t execCmd;
    // Handle TC requests, for example deletion or retrieval requests.
    result = store.handleCommandQueue(ipcStore, execCmd);
    if (result == returnvalue::OK) {
      if (execCmd == TmStoreMessage::DOWNLINK_STORE_CONTENT_TIME) {
        cancelDumpCd.resetTimer();
        tmSinkBusyCd.resetTimer();
        dumpContext.reset();
      }
      tcRequestReceived = true;
    }
  }
  if (tcRequestReceived or tmToStoreReceived or dumpPerformed) {
    return true;
  }
  return false;
}

bool TmStoreTaskBase::cyclicStoreCheck() {
  if (not storesInitialized) {
    storesInitialized = initStoresIfPossible();
    if (not storesInitialized) {
      TaskFactory::delayTask(400);
      return false;
    }
  } else if (sdCardCheckCd.hasTimedOut()) {
    if (not sdcMan.isSdCardUsable(std::nullopt)) {
      // Might be due to imminent shutdown or SD card switch.
      storesInitialized = false;
      TaskFactory::delayTask(100);
      return false;
    }
    sdCardCheckCd.resetTimer();
  }
  return true;
}

void TmStoreTaskBase::cancelDump(DumpContext& ctx, PersistentTmStore& store, bool isTxOn) {
  triggerEvent(ctx.eventIfCancelled, ctx.numberOfDumpedPackets, ctx.dumpedBytes);
  ctx.reset();
  store.cancelDump();
  if (isTxOn) {
    channel.cancelTransfer();
  }
}

ReturnValue_t TmStoreTaskBase::handleOneDump(PersistentTmStoreWithTmQueue& store,
                                             DumpContext& dumpContext, bool& dumpPerformed) {
  ReturnValue_t result = returnvalue::OK;
  // The PTME might have been reset an transmitter state change, so there is no point in continuing
  // the dump.
  if (not channel.isTxOn()) {
    cancelDump(dumpContext, store, false);
    return returnvalue::FAILED;
  }
  size_t dumpedLen = 0;
  if (not channel.isBusy()) {
    // Dump the next packet into the PTME.
    dumpContext.ptmeBusyCounter = 0;
    tmSinkBusyCd.resetTimer();
    result = store.dumpNextPacket(channel, dumpedLen, fileHasSwapped);
    if (result == DirectTmSinkIF::IS_BUSY) {
      sif::warning << "Unexpected PAPB busy" << std::endl;
    }
    if ((result == PersistentTmStore::DUMP_DONE or result == returnvalue::OK)) {
      dumpPerformed = true;
      if (dumpedLen > 0) {
        dumpContext.dumpedBytes += dumpedLen;
        dumpContext.numberOfDumpedPackets += 1;
        dumpContext.packetWasDumped = true;
      }
    }
    if (result == PersistentTmStore::DUMP_DONE) {
      uint32_t startTime;
      uint32_t endTime;
      store.getStartAndEndTimeCurrentOrLastDump(startTime, endTime);
      triggerEvent(dumpContext.eventIfDone, dumpContext.numberOfDumpedPackets,
                   dumpContext.dumpedBytes);
      dumpContext.reset();
    }
  } else {
    // The PTME might be at full load, so it might sense to delay for a bit to let it do
    // its work until some more bandwidth is available. Set a flag here so the upper layer can
    // do this.
    dumpContext.vcBusyDuringDump = true;
    dumpContext.ptmeBusyCounter++;
    if (dumpContext.ptmeBusyCounter == 200) {
      // If this happens, something is probably wrong.
      sif::warning << "PTME busy for longer period. Cancelling dump" << std::endl;
      cancelDump(dumpContext, store, channel.isTxOn());
    }
  }
  if (cancelDumpCd.hasTimedOut() or tmSinkBusyCd.hasTimedOut()) {
    cancelDump(dumpContext, store, channel.isTxOn());
  }
  return result;
}