eive-obsw/mission/system/AcsBoardAssembly.h

#ifndef MISSION_SYSTEM_ACSBOARDASSEMBLY_H_
#define MISSION_SYSTEM_ACSBOARDASSEMBLY_H_

#include <common/config/commonSubsystemIds.h>
#include <devices/powerSwitcherList.h>
#include <fsfw/devicehandlers/AssemblyBase.h>
#include <fsfw/objectmanager/frameworkObjects.h>

#include "DualLanePowerStateMachine.h"

struct AcsBoardHelper {
  AcsBoardHelper(object_id_t mgm0Id, object_id_t mgm1Id, object_id_t mgm2Id, object_id_t mgm3Id,
                 object_id_t gyro0Id, object_id_t gyro1Id, object_id_t gyro2Id, object_id_t gyro3Id,
                 object_id_t gpsId)
      : mgm0Lis3IdSideA(mgm0Id),
        mgm1Rm3100IdSideA(mgm1Id),
        mgm2Lis3IdSideB(mgm2Id),
        mgm3Rm3100IdSideB(mgm3Id),
        gyro0AdisIdSideA(gyro0Id),
        gyro1L3gIdSideA(gyro1Id),
        gyro2AdisIdSideB(gyro2Id),
        gyro3L3gIdSideB(gyro3Id),
        gpsId(gpsId) {}

  object_id_t mgm0Lis3IdSideA = objects::NO_OBJECT;
  object_id_t mgm1Rm3100IdSideA = objects::NO_OBJECT;
  object_id_t mgm2Lis3IdSideB = objects::NO_OBJECT;
  object_id_t mgm3Rm3100IdSideB = objects::NO_OBJECT;

  object_id_t gyro0AdisIdSideA = objects::NO_OBJECT;
  object_id_t gyro1L3gIdSideA = objects::NO_OBJECT;
  object_id_t gyro2AdisIdSideB = objects::NO_OBJECT;
  object_id_t gyro3L3gIdSideB = objects::NO_OBJECT;

  object_id_t gpsId = objects::NO_OBJECT;

  Mode_t gyro0SideAMode = HasModesIF::MODE_OFF;
  Mode_t gyro1SideAMode = HasModesIF::MODE_OFF;
  Mode_t gyro2SideBMode = HasModesIF::MODE_OFF;
  Mode_t gyro3SideBMode = HasModesIF::MODE_OFF;
  Mode_t mgm0SideAMode = HasModesIF::MODE_OFF;
  Mode_t mgm1SideAMode = HasModesIF::MODE_OFF;
  Mode_t mgm2SideBMode = HasModesIF::MODE_OFF;
  Mode_t mgm3SideBMode = HasModesIF::MODE_OFF;
  Mode_t gpsMode = HasModesIF::MODE_OFF;
};

enum ModeTableIdx : uint8_t {
  MGM_0_A = 0,
  MGM_1_A = 1,
  MGM_2_B = 2,
  MGM_3_B = 3,
  GYRO_0_A = 4,
  GYRO_1_A = 5,
  GYRO_2_B = 6,
  GYRO_3_B = 7,
  GPS = 8
};

class PowerSwitchIF;
class GpioIF;

/**
 * @brief  Assembly class which manages redundant ACS board sides
 * @details
 * This class takes care of ensuring that enough devices on the ACS board are available at all
 * times. It does so by doing autonomous transitions to the redundant side or activating both sides
 * if not enough devices are available.
 *
 * This class also takes care of switching on the A side and/or B side power lanes. Normally,
 * doing this task would be performed by the device handlers, but this is not possible for the
 * ACS board where multiple sensors share the same power supply.
 */
class AcsBoardAssembly : public AssemblyBase {
 public:
  static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::ACS_BOARD_ASS;
  static constexpr Event TRANSITION_OTHER_SIDE_FAILED =
      event::makeEvent(SUBSYSTEM_ID, 0, severity::HIGH);
  static constexpr Event NOT_ENOUGH_DEVICES_DUAL_MODE =
      event::makeEvent(SUBSYSTEM_ID, 1, severity::HIGH);
  static constexpr Event POWER_STATE_MACHINE_TIMEOUT =
      event::makeEvent(SUBSYSTEM_ID, 2, severity::MEDIUM);

  static constexpr uint8_t NUMBER_DEVICES_MODE_TABLE = 9;

  AcsBoardAssembly(object_id_t objectId, object_id_t parentId, PowerSwitchIF* pwrSwitcher,
                   AcsBoardHelper helper, GpioIF* gpioIF);

  void setPreferredSide(duallane::Submodes submode);

  /**
   * In dual mode, the A side or the B side GPS device can be used, but not both.
   * This function can be used to switch the used GPS device.
   * @param side
   */
  void selectGpsInDualMode(duallane::Submodes side);

 private:
  static constexpr pcduSwitches::Switches SWITCH_A =
      pcduSwitches::Switches::PDU1_CH7_ACS_A_SIDE_3V3;
  static constexpr pcduSwitches::Switches SWITCH_B =
      pcduSwitches::Switches::PDU2_CH7_ACS_BOARD_SIDE_B_3V3;

  // This helper object complete encapsulates power switching
  DualLanePowerStateMachine pwrStateMachine;
  bool tryingOtherSide = false;
  AcsBoardHelper helper;
  GpioIF* gpioIF = nullptr;
  uint8_t powerRetryCounter = 0;
  // duallane::PwrStates state = duallane::PwrStates::IDLE;
  duallane::Submodes defaultSubmode = duallane::Submodes::A_SIDE;
  bool dualModeErrorSwitch = true;
  FixedArrayList<ModeListEntry, NUMBER_DEVICES_MODE_TABLE> modeTable;

  ReturnValue_t initialize() override;

  // AssemblyBase overrides
  ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) override;
  ReturnValue_t checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) override;
  ReturnValue_t isModeCombinationValid(Mode_t mode, Submode_t submode) override;
  void performChildOperation() override;
  void startTransition(Mode_t mode, Submode_t submode) override;
  void handleModeReached() override;
  void handleModeTransitionFailed(ReturnValue_t result) override;
  void handleChildrenLostMode(ReturnValue_t result) override;

  /**
   * Check whether it makes sense to send mode commands to the device
   * @param object
   * @param mode
   * @return
   */
  bool isUseable(object_id_t object, Mode_t mode);
  ReturnValue_t handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode);
  void initModeTableEntry(object_id_t id, ModeListEntry& entry);
  void refreshHelperModes();
  void finishModeOp();
  /**
   * Thin wrapper function which is required because the helper class
   * can not access protected member functions.
   * @param mode
   * @param submode
   */
  ReturnValue_t pwrStateMachineWrapper();
};

#endif /* MISSION_SYSTEM_ACSBOARDASSEMBLY_H_ */