fsfw/src/fsfw/thermal/ThermalComponent.cpp

#include "fsfw/thermal/ThermalComponent.h"

ThermalComponent::ThermalComponent(object_id_t reportingObjectId, uint8_t domainId,
                                   gp_id_t temperaturePoolId, gp_id_t targetStatePoolId,
                                   gp_id_t currentStatePoolId, gp_id_t requestPoolId,
                                   LocalPoolDataSetBase* dataSet, AbstractTemperatureSensor* sensor,
                                   AbstractTemperatureSensor* firstRedundantSensor,
                                   AbstractTemperatureSensor* secondRedundantSensor,
                                   ThermalModuleIF* thermalModule, Parameters parameters,
                                   Priority priority)
    : ThermalComponentCore(reportingObjectId, domainId, temperaturePoolId, targetStatePoolId,
                           currentStatePoolId, requestPoolId, dataSet,
                           {parameters.lowerOpLimit, parameters.upperOpLimit, parameters.heaterOn,
                            parameters.hysteresis, parameters.heaterSwitchoff},
                           ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL),
      nopParameters({parameters.lowerNopLimit, parameters.upperNopLimit}) {}

ThermalComponent::~ThermalComponent() {}

ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
  targetState.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
  targetState.read();
  if ((targetState == STATE_REQUEST_OPERATIONAL) and (newState != STATE_REQUEST_IGNORE)) {
    return HasReturnvaluesIF::RETURN_FAILED;
  }
  switch (newState) {
    case STATE_REQUEST_NON_OPERATIONAL:
      targetState = newState;
      targetState.setValid(true);
      targetState.commit(PoolVariableIF::VALID);
      return HasReturnvaluesIF::RETURN_OK;
    default:
      return ThermalComponentCore::setTargetState(newState);
  }
  return HasReturnvaluesIF::RETURN_OK;
}

ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
  if (size != 4 * sizeof(parameters.lowerOpLimit)) {
    return MonitoringIF::INVALID_SIZE;
  }
  size_t readSize = size;
  SerializeAdapter::deSerialize(&nopParameters.lowerNopLimit, &data, &readSize,
                                SerializeIF::Endianness::BIG);
  SerializeAdapter::deSerialize(&parameters.lowerOpLimit, &data, &readSize,
                                SerializeIF::Endianness::BIG);
  SerializeAdapter::deSerialize(&parameters.upperOpLimit, &data, &readSize,
                                SerializeIF::Endianness::BIG);
  SerializeAdapter::deSerialize(&nopParameters.upperNopLimit, &data, &readSize,
                                SerializeIF::Endianness::BIG);
  return HasReturnvaluesIF::RETURN_OK;
}

ThermalComponentIF::State ThermalComponent::getState(float temperature,
                                                     ThermalComponentCore::Parameters parameters,
                                                     int8_t targetState) {
  if (temperature < nopParameters.lowerNopLimit) {
    return OUT_OF_RANGE_LOW;
  } else {
    State state = ThermalComponentCore::getState(temperature, parameters, targetState);
    if (state != NON_OPERATIONAL_HIGH && state != NON_OPERATIONAL_HIGH_IGNORED) {
      return state;
    }
    if (temperature > nopParameters.upperNopLimit) {
      state = OUT_OF_RANGE_HIGH;
    }
    if (targetState == STATE_REQUEST_IGNORE) {
      state = getIgnoredState(state);
    }
    return state;
  }
}

void ThermalComponent::checkLimits(ThermalComponentIF::State state) {
  if ((targetState == STATE_REQUEST_OPERATIONAL) or (targetState == STATE_REQUEST_IGNORE)) {
    ThermalComponentCore::checkLimits(state);
    return;
  }
  // If component is not operational, it checks the NOP limits.
  temperatureMonitor.translateState(state, temperature.value, nopParameters.lowerNopLimit,
                                    nopParameters.upperNopLimit, false);
}

ThermalComponentIF::HeaterRequest ThermalComponent::getHeaterRequest(
    int8_t targetState, float temperature, ThermalComponentCore::Parameters parameters) {
  if (targetState == STATE_REQUEST_IGNORE) {
    isHeating = false;
    return HEATER_DONT_CARE;
  }

  if (temperature > nopParameters.upperNopLimit - parameters.heaterSwitchoff) {
    isHeating = false;
    return HEATER_REQUEST_EMERGENCY_OFF;
  }

  float nopHeaterLimit = nopParameters.lowerNopLimit + parameters.heaterOn;
  float opHeaterLimit = parameters.lowerOpLimit + parameters.heaterOn;

  if (isHeating) {
    nopHeaterLimit += parameters.hysteresis;
    opHeaterLimit += parameters.hysteresis;
  }

  if (temperature < nopHeaterLimit) {
    isHeating = true;
    return HEATER_REQUEST_EMERGENCY_ON;
  }

  if ((targetState == STATE_REQUEST_OPERATIONAL) || (targetState == STATE_REQUEST_HEATING)) {
    if (temperature < opHeaterLimit) {
      isHeating = true;
      return HEATER_REQUEST_ON;
    }
    if (temperature > parameters.upperOpLimit - parameters.heaterSwitchoff) {
      isHeating = false;
      return HEATER_REQUEST_OFF;
    }
  }

  isHeating = false;
  return HEATER_DONT_CARE;
}

ThermalComponentIF::State ThermalComponent::getIgnoredState(int8_t state) {
  switch (state) {
    case OUT_OF_RANGE_LOW:
      return OUT_OF_RANGE_LOW_IGNORED;
    case OUT_OF_RANGE_HIGH:
      return OUT_OF_RANGE_HIGH_IGNORED;
    case OUT_OF_RANGE_LOW_IGNORED:
      return OUT_OF_RANGE_LOW_IGNORED;
    case OUT_OF_RANGE_HIGH_IGNORED:
      return OUT_OF_RANGE_HIGH_IGNORED;
    default:
      return ThermalComponentCore::getIgnoredState(state);
  }
}

ReturnValue_t ThermalComponent::getParameter(uint8_t domainId, uint8_t uniqueId,
                                             ParameterWrapper* parameterWrapper,
                                             const ParameterWrapper* newValues,
                                             uint16_t startAtIndex) {
  ReturnValue_t result = ThermalComponentCore::getParameter(domainId, uniqueId, parameterWrapper,
                                                            newValues, startAtIndex);
  if (result != INVALID_IDENTIFIER_ID) {
    return result;
  }
  switch (uniqueId) {
    case 12:
      parameterWrapper->set(nopParameters.lowerNopLimit);
      break;
    case 13:
      parameterWrapper->set(nopParameters.upperNopLimit);
      break;
    default:
      return INVALID_IDENTIFIER_ID;
  }
  return HasReturnvaluesIF::RETURN_OK;
}