release 0.0.1 of fsfw added as a core
This commit is contained in:
70
fsfw/thermal/AbstractTemperatureSensor.cpp
Normal file
70
fsfw/thermal/AbstractTemperatureSensor.cpp
Normal file
@ -0,0 +1,70 @@
|
||||
#include "AbstractTemperatureSensor.h"
|
||||
#include "../ipc/QueueFactory.h"
|
||||
|
||||
AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
|
||||
ThermalModuleIF *thermalModule) :
|
||||
SystemObject(setObjectid), commandQueue(NULL), healthHelper(this,
|
||||
setObjectid), parameterHelper(this) {
|
||||
if (thermalModule != NULL) {
|
||||
thermalModule->registerSensor(this);
|
||||
}
|
||||
commandQueue = QueueFactory::instance()->createMessageQueue();
|
||||
}
|
||||
|
||||
AbstractTemperatureSensor::~AbstractTemperatureSensor() {
|
||||
QueueFactory::instance()->deleteMessageQueue(commandQueue);
|
||||
}
|
||||
|
||||
MessageQueueId_t AbstractTemperatureSensor::getCommandQueue() const {
|
||||
return commandQueue->getId();
|
||||
}
|
||||
|
||||
ReturnValue_t AbstractTemperatureSensor::initialize() {
|
||||
ReturnValue_t result = SystemObject::initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = healthHelper.initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = parameterHelper.initialize();
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t AbstractTemperatureSensor::performOperation(uint8_t opCode) {
|
||||
handleCommandQueue();
|
||||
doChildOperation();
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
|
||||
handleCommandQueue();
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
void AbstractTemperatureSensor::handleCommandQueue() {
|
||||
CommandMessage message;
|
||||
ReturnValue_t result = commandQueue->receiveMessage(&message);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
result = healthHelper.handleHealthCommand(&message);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
return;
|
||||
}
|
||||
result = parameterHelper.handleParameterMessage(&message);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
return;
|
||||
}
|
||||
message.setToUnknownCommand();
|
||||
commandQueue->reply(&message);
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t AbstractTemperatureSensor::setHealth(HealthState health) {
|
||||
healthHelper.setHealth(health);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
HasHealthIF::HealthState AbstractTemperatureSensor::getHealth() {
|
||||
return healthHelper.getHealth();
|
||||
}
|
||||
54
fsfw/thermal/AbstractTemperatureSensor.h
Normal file
54
fsfw/thermal/AbstractTemperatureSensor.h
Normal file
@ -0,0 +1,54 @@
|
||||
#ifndef ABSTRACTSENSOR_H_
|
||||
#define ABSTRACTSENSOR_H_
|
||||
|
||||
#include "../health/HasHealthIF.h"
|
||||
#include "../health/HealthHelper.h"
|
||||
#include "../objectmanager/SystemObject.h"
|
||||
#include "../tasks/ExecutableObjectIF.h"
|
||||
#include "../parameters/ParameterHelper.h"
|
||||
#include "../ipc/MessageQueueIF.h"
|
||||
#include "ThermalModuleIF.h"
|
||||
#include "tcsDefinitions.h"
|
||||
|
||||
class AbstractTemperatureSensor: public HasHealthIF,
|
||||
public SystemObject,
|
||||
public ExecutableObjectIF,
|
||||
public ReceivesParameterMessagesIF {
|
||||
public:
|
||||
|
||||
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::T_SENSORS;
|
||||
static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, SEVERITY::LOW);
|
||||
static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, SEVERITY::LOW);
|
||||
static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, SEVERITY::LOW);
|
||||
|
||||
static constexpr float ZERO_KELVIN_C = -273.15;
|
||||
AbstractTemperatureSensor(object_id_t setObjectid,
|
||||
ThermalModuleIF *thermalModule);
|
||||
virtual ~AbstractTemperatureSensor();
|
||||
|
||||
virtual MessageQueueId_t getCommandQueue() const;
|
||||
|
||||
ReturnValue_t initialize();
|
||||
|
||||
ReturnValue_t performHealthOp();
|
||||
|
||||
ReturnValue_t performOperation(uint8_t opCode);
|
||||
|
||||
virtual float getTemperature() = 0;
|
||||
virtual bool isValid() = 0;
|
||||
|
||||
virtual void resetOldState() = 0;
|
||||
|
||||
ReturnValue_t setHealth(HealthState health);
|
||||
HasHealthIF::HealthState getHealth();
|
||||
protected:
|
||||
MessageQueueIF* commandQueue;
|
||||
HealthHelper healthHelper;
|
||||
ParameterHelper parameterHelper;
|
||||
|
||||
virtual void doChildOperation() = 0;
|
||||
|
||||
void handleCommandQueue();
|
||||
};
|
||||
|
||||
#endif /* ABSTRACTSENSOR_H_ */
|
||||
257
fsfw/thermal/CoreComponent.cpp
Normal file
257
fsfw/thermal/CoreComponent.cpp
Normal file
@ -0,0 +1,257 @@
|
||||
#include "CoreComponent.h"
|
||||
|
||||
CoreComponent::CoreComponent(object_id_t reportingObjectId, uint8_t domainId,
|
||||
uint32_t temperaturePoolId, uint32_t targetStatePoolId,
|
||||
uint32_t currentStatePoolId, uint32_t requestPoolId, DataSet* dataSet,
|
||||
AbstractTemperatureSensor* sensor,
|
||||
AbstractTemperatureSensor* firstRedundantSensor,
|
||||
AbstractTemperatureSensor* secondRedundantSensor,
|
||||
ThermalModuleIF* thermalModule, Parameters parameters,
|
||||
Priority priority, StateRequest initialTargetState) :
|
||||
sensor(sensor), firstRedundantSensor(firstRedundantSensor), secondRedundantSensor(
|
||||
secondRedundantSensor), thermalModule(thermalModule), temperature(
|
||||
temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
|
||||
targetStatePoolId, dataSet, PoolVariableIF::VAR_READ), currentState(
|
||||
currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), heaterRequest(
|
||||
requestPoolId, dataSet, PoolVariableIF::VAR_WRITE), isHeating(
|
||||
false), isSafeComponent(priority == SAFE), minTemp(999), maxTemp(
|
||||
AbstractTemperatureSensor::ZERO_KELVIN_C), parameters(
|
||||
parameters), temperatureMonitor(reportingObjectId,
|
||||
domainId + 1,
|
||||
DataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
|
||||
COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
|
||||
if (thermalModule != NULL) {
|
||||
thermalModule->registerComponent(this, priority);
|
||||
}
|
||||
//Set thermal state once, then leave to operator.
|
||||
DataSet mySet;
|
||||
PoolVariable<int8_t> writableTargetState(targetStatePoolId, &mySet,
|
||||
PoolVariableIF::VAR_WRITE);
|
||||
writableTargetState = initialTargetState;
|
||||
mySet.commit(PoolVariableIF::VALID);
|
||||
}
|
||||
|
||||
CoreComponent::~CoreComponent() {
|
||||
}
|
||||
|
||||
ThermalComponentIF::HeaterRequest CoreComponent::performOperation(uint8_t opCode) {
|
||||
HeaterRequest request = HEATER_DONT_CARE;
|
||||
//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
|
||||
temperature = getTemperature();
|
||||
updateMinMaxTemp();
|
||||
if ((temperature != INVALID_TEMPERATURE)) {
|
||||
temperature.setValid(PoolVariableIF::VALID);
|
||||
State state = getState(temperature, getParameters(), targetState);
|
||||
currentState = state;
|
||||
checkLimits(state);
|
||||
request = getHeaterRequest(targetState, temperature, getParameters());
|
||||
} else {
|
||||
temperatureMonitor.setToInvalid();
|
||||
temperature.setValid(PoolVariableIF::INVALID);
|
||||
currentState = UNKNOWN;
|
||||
request = HEATER_DONT_CARE;
|
||||
}
|
||||
currentState.setValid(PoolVariableIF::VALID);
|
||||
heaterRequest = request;
|
||||
heaterRequest.setValid(PoolVariableIF::VALID);
|
||||
return request;
|
||||
}
|
||||
|
||||
void CoreComponent::markStateIgnored() {
|
||||
currentState = getIgnoredState(currentState);
|
||||
}
|
||||
|
||||
object_id_t CoreComponent::getObjectId() {
|
||||
return temperatureMonitor.getReporterId();
|
||||
}
|
||||
|
||||
float CoreComponent::getLowerOpLimit() {
|
||||
return parameters.lowerOpLimit;
|
||||
}
|
||||
|
||||
ReturnValue_t CoreComponent::setTargetState(int8_t newState) {
|
||||
DataSet mySet;
|
||||
PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
|
||||
&mySet, PoolVariableIF::VAR_READ_WRITE);
|
||||
mySet.read();
|
||||
if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
|
||||
&& (newState != STATE_REQUEST_IGNORE)) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
switch (newState) {
|
||||
case STATE_REQUEST_HEATING:
|
||||
case STATE_REQUEST_IGNORE:
|
||||
case STATE_REQUEST_OPERATIONAL:
|
||||
writableTargetState = newState;
|
||||
break;
|
||||
case STATE_REQUEST_NON_OPERATIONAL:
|
||||
default:
|
||||
return INVALID_TARGET_STATE;
|
||||
}
|
||||
mySet.commit(PoolVariableIF::VALID);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
void CoreComponent::setOutputInvalid() {
|
||||
temperature = INVALID_TEMPERATURE;
|
||||
temperature.setValid(PoolVariableIF::INVALID);
|
||||
currentState.setValid(PoolVariableIF::INVALID);
|
||||
heaterRequest = HEATER_DONT_CARE;
|
||||
heaterRequest.setValid(PoolVariableIF::INVALID);
|
||||
temperatureMonitor.setToUnchecked();
|
||||
}
|
||||
|
||||
float CoreComponent::getTemperature() {
|
||||
if ((sensor != NULL) && (sensor->isValid())) {
|
||||
return sensor->getTemperature();
|
||||
}
|
||||
|
||||
if ((firstRedundantSensor != NULL) && (firstRedundantSensor->isValid())) {
|
||||
return firstRedundantSensor->getTemperature();
|
||||
}
|
||||
|
||||
if ((secondRedundantSensor != NULL) && (secondRedundantSensor->isValid())) {
|
||||
return secondRedundantSensor->getTemperature();
|
||||
}
|
||||
|
||||
if (thermalModule != NULL) {
|
||||
float temperature = thermalModule->getTemperature();
|
||||
if (temperature != ThermalModuleIF::INVALID_TEMPERATURE) {
|
||||
return temperature;
|
||||
} else {
|
||||
return INVALID_TEMPERATURE;
|
||||
}
|
||||
} else {
|
||||
return INVALID_TEMPERATURE;
|
||||
}
|
||||
}
|
||||
|
||||
ThermalComponentIF::State CoreComponent::getState(float temperature,
|
||||
Parameters parameters, int8_t targetState) {
|
||||
ThermalComponentIF::State state;
|
||||
|
||||
if (temperature < parameters.lowerOpLimit) {
|
||||
state = NON_OPERATIONAL_LOW;
|
||||
} else if (temperature < parameters.upperOpLimit) {
|
||||
state = OPERATIONAL;
|
||||
} else {
|
||||
state = NON_OPERATIONAL_HIGH;
|
||||
}
|
||||
if (targetState == STATE_REQUEST_IGNORE) {
|
||||
state = getIgnoredState(state);
|
||||
}
|
||||
|
||||
return state;
|
||||
}
|
||||
|
||||
void CoreComponent::checkLimits(ThermalComponentIF::State state) {
|
||||
//Checks operational limits only.
|
||||
temperatureMonitor.translateState(state, temperature.value,
|
||||
getParameters().lowerOpLimit, getParameters().upperOpLimit);
|
||||
|
||||
}
|
||||
|
||||
ThermalComponentIF::HeaterRequest CoreComponent::getHeaterRequest(
|
||||
int8_t targetState, float temperature, Parameters parameters) {
|
||||
if (targetState == STATE_REQUEST_IGNORE) {
|
||||
isHeating = false;
|
||||
return HEATER_DONT_CARE;
|
||||
}
|
||||
|
||||
if (temperature > parameters.upperOpLimit - parameters.heaterSwitchoff) {
|
||||
isHeating = false;
|
||||
return HEATER_REQUEST_EMERGENCY_OFF;
|
||||
}
|
||||
|
||||
float opHeaterLimit = parameters.lowerOpLimit + parameters.heaterOn;
|
||||
|
||||
if (isHeating) {
|
||||
opHeaterLimit += parameters.hysteresis;
|
||||
}
|
||||
|
||||
if (temperature < opHeaterLimit) {
|
||||
isHeating = true;
|
||||
return HEATER_REQUEST_EMERGENCY_ON;
|
||||
}
|
||||
isHeating = false;
|
||||
return HEATER_DONT_CARE;
|
||||
}
|
||||
|
||||
ThermalComponentIF::State CoreComponent::getIgnoredState(int8_t state) {
|
||||
switch (state) {
|
||||
case NON_OPERATIONAL_LOW:
|
||||
return NON_OPERATIONAL_LOW_IGNORED;
|
||||
case OPERATIONAL:
|
||||
return OPERATIONAL_IGNORED;
|
||||
case NON_OPERATIONAL_HIGH:
|
||||
return NON_OPERATIONAL_HIGH_IGNORED;
|
||||
case NON_OPERATIONAL_LOW_IGNORED:
|
||||
return NON_OPERATIONAL_LOW_IGNORED;
|
||||
case OPERATIONAL_IGNORED:
|
||||
return OPERATIONAL_IGNORED;
|
||||
case NON_OPERATIONAL_HIGH_IGNORED:
|
||||
return NON_OPERATIONAL_HIGH_IGNORED;
|
||||
default:
|
||||
case UNKNOWN:
|
||||
return UNKNOWN;
|
||||
}
|
||||
}
|
||||
|
||||
void CoreComponent::updateMinMaxTemp() {
|
||||
if (temperature == INVALID_TEMPERATURE) {
|
||||
return;
|
||||
}
|
||||
if (temperature < minTemp) {
|
||||
minTemp = temperature;
|
||||
}
|
||||
if (temperature > maxTemp) {
|
||||
maxTemp = temperature;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t CoreComponent::getDomainId() const {
|
||||
return domainId;
|
||||
}
|
||||
|
||||
CoreComponent::Parameters CoreComponent::getParameters() {
|
||||
return parameters;
|
||||
}
|
||||
|
||||
ReturnValue_t CoreComponent::getParameter(uint8_t domainId,
|
||||
uint16_t parameterId, ParameterWrapper* parameterWrapper,
|
||||
const ParameterWrapper* newValues, uint16_t startAtIndex) {
|
||||
ReturnValue_t result = temperatureMonitor.getParameter(domainId,
|
||||
parameterId, parameterWrapper, newValues, startAtIndex);
|
||||
if (result != INVALID_DOMAIN_ID) {
|
||||
return result;
|
||||
}
|
||||
if (domainId != this->domainId) {
|
||||
return INVALID_DOMAIN_ID;
|
||||
}
|
||||
switch (parameterId) {
|
||||
case 0:
|
||||
parameterWrapper->set(parameters.heaterOn);
|
||||
break;
|
||||
case 1:
|
||||
parameterWrapper->set(parameters.hysteresis);
|
||||
break;
|
||||
case 2:
|
||||
parameterWrapper->set(parameters.heaterSwitchoff);
|
||||
break;
|
||||
case 3:
|
||||
parameterWrapper->set(minTemp);
|
||||
break;
|
||||
case 4:
|
||||
parameterWrapper->set(maxTemp);
|
||||
break;
|
||||
case 10:
|
||||
parameterWrapper->set(parameters.lowerOpLimit);
|
||||
break;
|
||||
case 11:
|
||||
parameterWrapper->set(parameters.upperOpLimit);
|
||||
break;
|
||||
default:
|
||||
return INVALID_MATRIX_ID;
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
95
fsfw/thermal/CoreComponent.h
Normal file
95
fsfw/thermal/CoreComponent.h
Normal file
@ -0,0 +1,95 @@
|
||||
#ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
|
||||
#define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
|
||||
|
||||
#include "../datapool/DataSet.h"
|
||||
#include "../datapool/PoolVariable.h"
|
||||
#include "ThermalComponentIF.h"
|
||||
#include "AbstractTemperatureSensor.h"
|
||||
#include "ThermalModule.h"
|
||||
#include "ThermalMonitor.h"
|
||||
|
||||
class CoreComponent: public ThermalComponentIF {
|
||||
public:
|
||||
struct Parameters {
|
||||
float lowerOpLimit;
|
||||
float upperOpLimit;
|
||||
float heaterOn;
|
||||
float hysteresis;
|
||||
float heaterSwitchoff;
|
||||
};
|
||||
|
||||
static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
|
||||
|
||||
CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
|
||||
uint32_t targetStatePoolId, uint32_t currentStatePoolId,
|
||||
uint32_t requestPoolId, DataSet *dataSet,
|
||||
AbstractTemperatureSensor *sensor,
|
||||
AbstractTemperatureSensor *firstRedundantSensor,
|
||||
AbstractTemperatureSensor *secondRedundantSensor,
|
||||
ThermalModuleIF *thermalModule, Parameters parameters,
|
||||
Priority priority, StateRequest initialTargetState =
|
||||
ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
|
||||
|
||||
virtual ~CoreComponent();
|
||||
|
||||
virtual HeaterRequest performOperation(uint8_t opCode);
|
||||
|
||||
void markStateIgnored();
|
||||
|
||||
object_id_t getObjectId();
|
||||
|
||||
uint8_t getDomainId() const;
|
||||
|
||||
virtual float getLowerOpLimit();
|
||||
|
||||
ReturnValue_t setTargetState(int8_t newState);
|
||||
|
||||
virtual void setOutputInvalid();
|
||||
|
||||
virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
|
||||
ParameterWrapper *parameterWrapper,
|
||||
const ParameterWrapper *newValues, uint16_t startAtIndex);
|
||||
|
||||
protected:
|
||||
|
||||
AbstractTemperatureSensor *sensor;
|
||||
AbstractTemperatureSensor *firstRedundantSensor;
|
||||
AbstractTemperatureSensor *secondRedundantSensor;
|
||||
ThermalModuleIF *thermalModule;
|
||||
|
||||
db_float_t temperature;
|
||||
db_int8_t targetState;
|
||||
db_int8_t currentState;
|
||||
db_uint8_t heaterRequest;
|
||||
|
||||
bool isHeating;
|
||||
|
||||
bool isSafeComponent;
|
||||
|
||||
float minTemp;
|
||||
|
||||
float maxTemp;
|
||||
|
||||
Parameters parameters;
|
||||
|
||||
ThermalMonitor temperatureMonitor;
|
||||
|
||||
const uint8_t domainId;
|
||||
|
||||
virtual float getTemperature();
|
||||
virtual State getState(float temperature, Parameters parameters,
|
||||
int8_t targetState);
|
||||
|
||||
virtual void checkLimits(State state);
|
||||
|
||||
virtual HeaterRequest getHeaterRequest(int8_t targetState,
|
||||
float temperature, Parameters parameters);
|
||||
|
||||
virtual State getIgnoredState(int8_t state);
|
||||
|
||||
void updateMinMaxTemp();
|
||||
|
||||
virtual Parameters getParameters();
|
||||
};
|
||||
|
||||
#endif /* MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ */
|
||||
350
fsfw/thermal/Heater.cpp
Normal file
350
fsfw/thermal/Heater.cpp
Normal file
@ -0,0 +1,350 @@
|
||||
#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
|
||||
#include "Heater.h"
|
||||
|
||||
#include "../power/Fuse.h"
|
||||
#include "../ipc/QueueFactory.h"
|
||||
|
||||
Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) :
|
||||
HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
|
||||
NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(
|
||||
false), timedOut(false), reactedToBeingFaulty(false), passive(
|
||||
false), eventQueue(NULL), heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(
|
||||
this), lastAction(CLEAR) {
|
||||
eventQueue = QueueFactory::instance()->createMessageQueue();
|
||||
}
|
||||
|
||||
Heater::~Heater() {
|
||||
QueueFactory::instance()->deleteMessageQueue(eventQueue);
|
||||
}
|
||||
|
||||
ReturnValue_t Heater::set() {
|
||||
passive = false;
|
||||
//wait for clear before doing anything
|
||||
if (internalState == STATE_WAIT) {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
if (healthHelper.healthTable->isHealthy(getObjectId())) {
|
||||
doAction(SET);
|
||||
if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
} else {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
} else {
|
||||
if (healthHelper.healthTable->isFaulty(getObjectId())) {
|
||||
if (!reactedToBeingFaulty) {
|
||||
reactedToBeingFaulty = true;
|
||||
doAction(CLEAR);
|
||||
}
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
}
|
||||
|
||||
void Heater::clear(bool passive) {
|
||||
this->passive = passive;
|
||||
//Force switching off
|
||||
if (internalState == STATE_WAIT) {
|
||||
internalState = STATE_ON;
|
||||
}
|
||||
if (healthHelper.healthTable->isHealthy(getObjectId())) {
|
||||
doAction(CLEAR);
|
||||
} else if (healthHelper.healthTable->isFaulty(getObjectId())) {
|
||||
if (!reactedToBeingFaulty) {
|
||||
reactedToBeingFaulty = true;
|
||||
doAction(CLEAR);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Heater::doAction(Action action) {
|
||||
//only act if we are not in the right state or in a transition
|
||||
if (action == SET) {
|
||||
if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
|
||||
|| (internalState == STATE_EXTERNAL_CONTROL)) {
|
||||
switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
|
||||
internalState = STATE_WAIT_FOR_SWITCHES_ON;
|
||||
powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
|
||||
powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
|
||||
}
|
||||
} else { //clear
|
||||
if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
|
||||
|| (internalState == STATE_EXTERNAL_CONTROL)) {
|
||||
internalState = STATE_WAIT_FOR_SWITCHES_OFF;
|
||||
switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
|
||||
powerSwitcher->sendSwitchCommand(switch0,
|
||||
PowerSwitchIF::SWITCH_OFF);
|
||||
powerSwitcher->sendSwitchCommand(switch1,
|
||||
PowerSwitchIF::SWITCH_OFF);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Heater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
|
||||
this->powerSwitcher = powerSwitch;
|
||||
}
|
||||
|
||||
ReturnValue_t Heater::performOperation(uint8_t opCode) {
|
||||
handleQueue();
|
||||
handleEventQueue();
|
||||
|
||||
if (!healthHelper.healthTable->isFaulty(getObjectId())) {
|
||||
reactedToBeingFaulty = false;
|
||||
}
|
||||
|
||||
switch (internalState) {
|
||||
case STATE_ON:
|
||||
if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
|
||||
|| (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_OFF)) {
|
||||
//switch went off on its own
|
||||
//trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
|
||||
//do not trigger FD events when under external control
|
||||
if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
|
||||
triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
|
||||
} else {
|
||||
internalState = STATE_EXTERNAL_CONTROL;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case STATE_OFF:
|
||||
//check if heater is on, ie both switches are on
|
||||
//if so, just command it to off, to resolve the situation or force a switch stayed on event
|
||||
//But, only do anything if not already faulty (state off is the stable point for being faulty)
|
||||
if ((!healthHelper.healthTable->isFaulty(getObjectId()))
|
||||
&& (powerSwitcher->getSwitchState(switch0)
|
||||
== PowerSwitchIF::SWITCH_ON)
|
||||
&& (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_ON)) {
|
||||
//do not trigger FD events when under external control
|
||||
if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
|
||||
internalState = STATE_WAIT_FOR_SWITCHES_OFF;
|
||||
switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
|
||||
powerSwitcher->sendSwitchCommand(switch0,
|
||||
PowerSwitchIF::SWITCH_OFF);
|
||||
powerSwitcher->sendSwitchCommand(switch1,
|
||||
PowerSwitchIF::SWITCH_OFF);
|
||||
} else {
|
||||
internalState = STATE_EXTERNAL_CONTROL;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case STATE_PASSIVE:
|
||||
break;
|
||||
case STATE_WAIT_FOR_SWITCHES_ON:
|
||||
if (switchCountdown.hasTimedOut()) {
|
||||
if ((powerSwitcher->getSwitchState(switch0)
|
||||
== PowerSwitchIF::SWITCH_OFF)
|
||||
|| (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_OFF)) {
|
||||
triggerEvent(HEATER_STAYED_OFF);
|
||||
internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
|
||||
} else {
|
||||
triggerEvent(HEATER_ON);
|
||||
internalState = STATE_ON;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case STATE_WAIT_FOR_SWITCHES_OFF:
|
||||
if (switchCountdown.hasTimedOut()) {
|
||||
//only check for both being on (ie heater still on)
|
||||
if ((powerSwitcher->getSwitchState(switch0)
|
||||
== PowerSwitchIF::SWITCH_ON)
|
||||
&& (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_ON)) {
|
||||
if (healthHelper.healthTable->isFaulty(getObjectId())) {
|
||||
if (passive) {
|
||||
internalState = STATE_PASSIVE;
|
||||
} else {
|
||||
internalState = STATE_OFF; //just accept it
|
||||
}
|
||||
triggerEvent(HEATER_ON); //but throw an event to make it more visible
|
||||
break;
|
||||
}
|
||||
triggerEvent(HEATER_STAYED_ON);
|
||||
internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
|
||||
} else {
|
||||
triggerEvent(HEATER_OFF);
|
||||
if (passive) {
|
||||
internalState = STATE_PASSIVE;
|
||||
} else {
|
||||
internalState = STATE_OFF;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
|
||||
&& (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_ON)) {
|
||||
if (wasOn) {
|
||||
if (heaterOnCountdown.hasTimedOut()) {
|
||||
//SHOULDDO this means if a heater fails in single mode, the timeout will start again
|
||||
//I am not sure if this is a bug, but atm I have no idea how to fix this and think
|
||||
//it will be ok. whatcouldpossiblygowrong™
|
||||
if (!timedOut) {
|
||||
triggerEvent(HEATER_TIMEOUT);
|
||||
timedOut = true;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
wasOn = true;
|
||||
heaterOnCountdown.resetTimer();
|
||||
timedOut = false;
|
||||
}
|
||||
} else {
|
||||
wasOn = false;
|
||||
}
|
||||
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
void Heater::setSwitch(uint8_t number, ReturnValue_t state,
|
||||
uint32_t* uptimeOfSwitching) {
|
||||
if (powerSwitcher == NULL) {
|
||||
return;
|
||||
}
|
||||
if (powerSwitcher->getSwitchState(number) == state) {
|
||||
*uptimeOfSwitching = INVALID_UPTIME;
|
||||
} else {
|
||||
if ((*uptimeOfSwitching == INVALID_UPTIME)) {
|
||||
powerSwitcher->sendSwitchCommand(number, state);
|
||||
Clock::getUptime(uptimeOfSwitching);
|
||||
} else {
|
||||
uint32_t currentUptime;
|
||||
Clock::getUptime(¤tUptime);
|
||||
if (currentUptime - *uptimeOfSwitching
|
||||
> powerSwitcher->getSwitchDelayMs()) {
|
||||
*uptimeOfSwitching = INVALID_UPTIME;
|
||||
if (healthHelper.healthTable->isHealthy(getObjectId())) {
|
||||
if (state == PowerSwitchIF::SWITCH_ON) {
|
||||
triggerEvent(HEATER_STAYED_OFF);
|
||||
} else {
|
||||
triggerEvent(HEATER_STAYED_ON);
|
||||
}
|
||||
}
|
||||
//SHOULDDO MiniOps during switch timeout leads to a faulty switch
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
MessageQueueId_t Heater::getCommandQueue() const {
|
||||
return commandQueue->getId();
|
||||
}
|
||||
|
||||
ReturnValue_t Heater::initialize() {
|
||||
ReturnValue_t result = SystemObject::initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
EventManagerIF* manager = objectManager->get<EventManagerIF>(
|
||||
objects::EVENT_MANAGER);
|
||||
if (manager == NULL) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
result = manager->registerListener(eventQueue->getId());
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
|
||||
DeviceHandlerFailureIsolation::powerConfirmationId);
|
||||
if (pcdu == NULL) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
pcduQueueId = pcdu->getEventReceptionQueue();
|
||||
|
||||
result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
|
||||
getObjectId());
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
result = parameterHelper.initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
result = healthHelper.initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
void Heater::handleQueue() {
|
||||
CommandMessage message;
|
||||
ReturnValue_t result = commandQueue->receiveMessage(&message);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
result = healthHelper.handleHealthCommand(&message);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
return;
|
||||
}
|
||||
parameterHelper.handleParameterMessage(&message);
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
|
||||
ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
|
||||
uint16_t startAtIndex) {
|
||||
if (domainId != DOMAIN_ID_BASE) {
|
||||
return INVALID_DOMAIN_ID;
|
||||
}
|
||||
switch (parameterId) {
|
||||
case 0:
|
||||
parameterWrapper->set(heaterOnCountdown.timeout);
|
||||
break;
|
||||
default:
|
||||
return INVALID_MATRIX_ID;
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
void Heater::handleEventQueue() {
|
||||
EventMessage event;
|
||||
for (ReturnValue_t result = eventQueue->receiveMessage(&event);
|
||||
result == HasReturnvaluesIF::RETURN_OK;
|
||||
result = eventQueue->receiveMessage(&event)) {
|
||||
switch (event.getMessageId()) {
|
||||
case EventMessage::EVENT_MESSAGE:
|
||||
switch (event.getEvent()) {
|
||||
case Fuse::FUSE_WENT_OFF:
|
||||
case HEATER_STAYED_OFF:
|
||||
case HEATER_STAYED_ON://Setting it faulty does not help, but we need to reach a stable state and can check for being faulty before throwing this event again.
|
||||
if (healthHelper.healthTable->isCommandable(getObjectId())) {
|
||||
healthHelper.setHealth(HasHealthIF::FAULTY);
|
||||
internalState = STATE_FAULTY;
|
||||
}
|
||||
break;
|
||||
case PowerSwitchIF::SWITCH_WENT_OFF:
|
||||
internalState = STATE_WAIT;
|
||||
event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
|
||||
if (pcduQueueId != 0) {
|
||||
eventQueue->sendMessage(pcduQueueId, &event);
|
||||
} else {
|
||||
healthHelper.setHealth(HasHealthIF::FAULTY);
|
||||
internalState = STATE_FAULTY;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case EventMessage::YOUR_FAULT:
|
||||
healthHelper.setHealth(HasHealthIF::FAULTY);
|
||||
internalState = STATE_FAULTY;
|
||||
break;
|
||||
case EventMessage::MY_FAULT:
|
||||
//do nothing, we are already in STATE_WAIT and wait for a clear()
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
90
fsfw/thermal/Heater.h
Normal file
90
fsfw/thermal/Heater.h
Normal file
@ -0,0 +1,90 @@
|
||||
#ifndef FRAMEWORK_THERMAL_HEATER_H_
|
||||
#define FRAMEWORK_THERMAL_HEATER_H_
|
||||
|
||||
#include "../devicehandlers/HealthDevice.h"
|
||||
#include "../parameters/ParameterHelper.h"
|
||||
#include "../power/PowerSwitchIF.h"
|
||||
#include "../returnvalues/HasReturnvaluesIF.h"
|
||||
#include "../timemanager/Countdown.h"
|
||||
#include <stdint.h>
|
||||
//class RedundantHeater;
|
||||
|
||||
class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
|
||||
friend class RedundantHeater;
|
||||
public:
|
||||
|
||||
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
|
||||
static const Event HEATER_ON = MAKE_EVENT(0, SEVERITY::INFO);
|
||||
static const Event HEATER_OFF = MAKE_EVENT(1, SEVERITY::INFO);
|
||||
static const Event HEATER_TIMEOUT = MAKE_EVENT(2, SEVERITY::LOW);
|
||||
static const Event HEATER_STAYED_ON = MAKE_EVENT(3, SEVERITY::LOW);
|
||||
static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, SEVERITY::LOW);
|
||||
|
||||
Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
|
||||
virtual ~Heater();
|
||||
|
||||
ReturnValue_t performOperation(uint8_t opCode);
|
||||
|
||||
ReturnValue_t initialize();
|
||||
|
||||
ReturnValue_t set();
|
||||
void clear(bool passive);
|
||||
|
||||
void setPowerSwitcher(PowerSwitchIF *powerSwitch);
|
||||
|
||||
MessageQueueId_t getCommandQueue() const;
|
||||
|
||||
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
|
||||
ParameterWrapper *parameterWrapper,
|
||||
const ParameterWrapper *newValues, uint16_t startAtIndex);
|
||||
|
||||
protected:
|
||||
static const uint32_t INVALID_UPTIME = 0;
|
||||
|
||||
enum InternalState {
|
||||
STATE_ON,
|
||||
STATE_OFF,
|
||||
STATE_PASSIVE,
|
||||
STATE_WAIT_FOR_SWITCHES_ON,
|
||||
STATE_WAIT_FOR_SWITCHES_OFF,
|
||||
STATE_WAIT_FOR_FDIR, //used to avoid doing anything until fdir decided what to do
|
||||
STATE_FAULTY,
|
||||
STATE_WAIT, //used when waiting for system to recover from miniops
|
||||
STATE_EXTERNAL_CONTROL //entered when under external control and a fdir reaction would be triggered. This is useful when leaving external control into an unknown state
|
||||
//if no fdir reaction is triggered under external control the state is still ok and no need for any special treatment is needed
|
||||
} internalState;
|
||||
|
||||
PowerSwitchIF *powerSwitcher;
|
||||
MessageQueueId_t pcduQueueId;
|
||||
|
||||
uint8_t switch0;
|
||||
uint8_t switch1;
|
||||
|
||||
bool wasOn;
|
||||
|
||||
bool timedOut;
|
||||
|
||||
bool reactedToBeingFaulty;
|
||||
|
||||
bool passive;
|
||||
|
||||
MessageQueueIF* eventQueue;
|
||||
Countdown heaterOnCountdown;
|
||||
Countdown switchCountdown;
|
||||
ParameterHelper parameterHelper;
|
||||
|
||||
enum Action {
|
||||
SET, CLEAR
|
||||
} lastAction;
|
||||
|
||||
void doAction(Action action);
|
||||
|
||||
void setSwitch(uint8_t number, ReturnValue_t state,
|
||||
uint32_t *upTimeOfSwitching);
|
||||
|
||||
void handleQueue();
|
||||
|
||||
void handleEventQueue();
|
||||
};
|
||||
|
||||
#endif /* FRAMEWORK_THERMAL_HEATER_H_ */
|
||||
40
fsfw/thermal/RedundantHeater.cpp
Normal file
40
fsfw/thermal/RedundantHeater.cpp
Normal file
@ -0,0 +1,40 @@
|
||||
#include "RedundantHeater.h"
|
||||
|
||||
RedundantHeater::~RedundantHeater() {
|
||||
}
|
||||
|
||||
RedundantHeater::RedundantHeater(Parameters parameters) :
|
||||
heater0(parameters.objectIdHeater0, parameters.switch0Heater0,
|
||||
parameters.switch1Heater0), heater1(parameters.objectIdHeater1,
|
||||
parameters.switch0Heater1, parameters.switch1Heater1) {
|
||||
}
|
||||
|
||||
void RedundantHeater::performOperation(uint8_t opCode) {
|
||||
heater0.performOperation(0);
|
||||
heater1.performOperation(0);
|
||||
}
|
||||
|
||||
void RedundantHeater::set(bool on, bool both, bool passive) {
|
||||
if (on) {
|
||||
ReturnValue_t result = heater0.set();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK || both) {
|
||||
heater1.set();
|
||||
} else {
|
||||
heater1.clear(passive);
|
||||
}
|
||||
} else {
|
||||
heater0.clear(passive);
|
||||
heater1.clear(passive);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void RedundantHeater::triggerHeaterEvent(Event event) {
|
||||
heater0.triggerEvent(event);
|
||||
heater1.triggerEvent(event);
|
||||
}
|
||||
|
||||
void RedundantHeater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
|
||||
heater0.setPowerSwitcher(powerSwitch);
|
||||
heater1.setPowerSwitcher(powerSwitch);
|
||||
}
|
||||
51
fsfw/thermal/RedundantHeater.h
Normal file
51
fsfw/thermal/RedundantHeater.h
Normal file
@ -0,0 +1,51 @@
|
||||
#ifndef REDUNDANTHEATER_H_
|
||||
#define REDUNDANTHEATER_H_
|
||||
|
||||
#include "Heater.h"
|
||||
|
||||
class RedundantHeater {
|
||||
public:
|
||||
|
||||
struct Parameters {
|
||||
Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
|
||||
uint8_t switch0Heater0, uint8_t switch1Heater0,
|
||||
uint8_t switch0Heater1, uint8_t switch1Heater1) :
|
||||
objectIdHeater0(objectIdHeater0), objectIdHeater1(
|
||||
objectIdHeater1), switch0Heater0(switch0Heater0), switch1Heater0(
|
||||
switch1Heater0), switch0Heater1(switch0Heater1), switch1Heater1(
|
||||
switch1Heater1) {
|
||||
}
|
||||
|
||||
Parameters() :
|
||||
objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0), switch1Heater0(
|
||||
0), switch0Heater1(0), switch1Heater1(0) {
|
||||
}
|
||||
|
||||
uint32_t objectIdHeater0;
|
||||
uint32_t objectIdHeater1;
|
||||
uint8_t switch0Heater0;
|
||||
uint8_t switch1Heater0;
|
||||
uint8_t switch0Heater1;
|
||||
uint8_t switch1Heater1;
|
||||
};
|
||||
|
||||
RedundantHeater(Parameters parameters);
|
||||
virtual ~RedundantHeater();
|
||||
|
||||
void performOperation(uint8_t opCode);
|
||||
|
||||
void triggerHeaterEvent(Event event);
|
||||
|
||||
void set(bool on, bool both, bool passive = false);
|
||||
|
||||
void setPowerSwitcher(PowerSwitchIF *powerSwitch);
|
||||
|
||||
protected:
|
||||
|
||||
Heater heater0;
|
||||
Heater heater1;
|
||||
|
||||
};
|
||||
|
||||
#endif /* REDUNDANTHEATER_H_ */
|
||||
|
||||
174
fsfw/thermal/TemperatureSensor.h
Normal file
174
fsfw/thermal/TemperatureSensor.h
Normal file
@ -0,0 +1,174 @@
|
||||
#ifndef TEMPERATURESENSOR_H_
|
||||
#define TEMPERATURESENSOR_H_
|
||||
|
||||
#include "../datapool/DataSet.h"
|
||||
#include "AbstractTemperatureSensor.h"
|
||||
#include "../monitoring/LimitMonitor.h"
|
||||
|
||||
template<typename T>
|
||||
class TemperatureSensor: public AbstractTemperatureSensor {
|
||||
public:
|
||||
struct Parameters {
|
||||
float a;
|
||||
float b;
|
||||
float c;
|
||||
T lowerLimit;
|
||||
T upperLimit;
|
||||
float gradient;
|
||||
};
|
||||
struct UsedParameters {
|
||||
UsedParameters(Parameters parameters) :
|
||||
a(parameters.a), b(parameters.b), c(parameters.c), gradient(
|
||||
parameters.gradient) {
|
||||
}
|
||||
float a;
|
||||
float b;
|
||||
float c;
|
||||
float gradient;
|
||||
};
|
||||
|
||||
static const uint16_t ADDRESS_A = 0;
|
||||
static const uint16_t ADDRESS_B = 1;
|
||||
static const uint16_t ADDRESS_C = 2;
|
||||
static const uint16_t ADDRESS_GRADIENT = 3;
|
||||
|
||||
static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
|
||||
|
||||
static const uint8_t DOMAIN_ID_SENSOR = 1;
|
||||
private:
|
||||
void setInvalid() {
|
||||
outputTemperature = INVALID_TEMPERATURE;
|
||||
outputTemperature.setValid(false);
|
||||
uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
|
||||
sensorMonitor.setToInvalid();
|
||||
}
|
||||
protected:
|
||||
static const int32_t INVALID_UPTIME = 0;
|
||||
|
||||
UsedParameters parameters;
|
||||
|
||||
T *inputTemperature;
|
||||
|
||||
PoolVariableIF *poolVariable;
|
||||
|
||||
PoolVariable<float> outputTemperature;
|
||||
|
||||
LimitMonitor<T> sensorMonitor;
|
||||
|
||||
float oldTemperature;
|
||||
timeval uptimeOfOldTemperature;
|
||||
|
||||
virtual float calculateOutputTemperature(T inputTemperature) {
|
||||
return parameters.a * inputTemperature * inputTemperature
|
||||
+ parameters.b * inputTemperature + parameters.c;
|
||||
}
|
||||
|
||||
void doChildOperation() {
|
||||
if (!poolVariable->isValid()
|
||||
|| !healthHelper.healthTable->isHealthy(getObjectId())) {
|
||||
setInvalid();
|
||||
return;
|
||||
}
|
||||
|
||||
outputTemperature = calculateOutputTemperature(*inputTemperature);
|
||||
outputTemperature.setValid(PoolVariableIF::VALID);
|
||||
|
||||
timeval uptime;
|
||||
Clock::getUptime(&uptime);
|
||||
|
||||
if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
|
||||
//In theory, we could use an AbsValueMonitor to monitor the gradient.
|
||||
//But this would require storing the gradient in DP and quite some overhead.
|
||||
//The concept of delta limits is a bit strange anyway.
|
||||
float deltaTime;
|
||||
float deltaTemp;
|
||||
|
||||
deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.)
|
||||
- (uptimeOfOldTemperature.tv_sec
|
||||
+ uptimeOfOldTemperature.tv_usec / 1000000.);
|
||||
deltaTemp = oldTemperature - outputTemperature;
|
||||
if (deltaTemp < 0) {
|
||||
deltaTemp = -deltaTemp;
|
||||
}
|
||||
if (parameters.gradient < deltaTemp / deltaTime) {
|
||||
triggerEvent(TEMP_SENSOR_GRADIENT);
|
||||
//Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
|
||||
}
|
||||
}
|
||||
|
||||
//Check is done against raw limits. SHOULDDO: Why? Using °C would be more easy to handle.
|
||||
sensorMonitor.doCheck(*inputTemperature);
|
||||
|
||||
if (sensorMonitor.isOutOfLimits()) {
|
||||
uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
|
||||
outputTemperature.setValid(PoolVariableIF::INVALID);
|
||||
outputTemperature = INVALID_TEMPERATURE;
|
||||
} else {
|
||||
oldTemperature = outputTemperature;
|
||||
uptimeOfOldTemperature = uptime;
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
TemperatureSensor(object_id_t setObjectid,
|
||||
T *inputTemperature, PoolVariableIF *poolVariable,
|
||||
uint8_t vectorIndex, Parameters parameters, uint32_t datapoolId,
|
||||
DataSet *outputSet, ThermalModuleIF *thermalModule) :
|
||||
AbstractTemperatureSensor(setObjectid, thermalModule), parameters(
|
||||
parameters), inputTemperature(inputTemperature), poolVariable(
|
||||
poolVariable), outputTemperature(datapoolId, outputSet,
|
||||
PoolVariableIF::VAR_WRITE), sensorMonitor(setObjectid,
|
||||
DOMAIN_ID_SENSOR,
|
||||
DataPool::poolIdAndPositionToPid(
|
||||
poolVariable->getDataPoolId(), vectorIndex),
|
||||
DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit,
|
||||
parameters.upperLimit, TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH), oldTemperature(
|
||||
20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
|
||||
|
||||
}
|
||||
|
||||
float getTemperature() {
|
||||
return outputTemperature;
|
||||
}
|
||||
|
||||
bool isValid() {
|
||||
return outputTemperature.isValid();
|
||||
}
|
||||
|
||||
virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
|
||||
ParameterWrapper *parameterWrapper,
|
||||
const ParameterWrapper *newValues, uint16_t startAtIndex) {
|
||||
ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
|
||||
parameterWrapper, newValues, startAtIndex);
|
||||
if (result != INVALID_DOMAIN_ID) {
|
||||
return result;
|
||||
}
|
||||
if (domainId != this->DOMAIN_ID_BASE) {
|
||||
return INVALID_DOMAIN_ID;
|
||||
}
|
||||
switch (parameterId) {
|
||||
case ADDRESS_A:
|
||||
parameterWrapper->set(parameters.a);
|
||||
break;
|
||||
case ADDRESS_B:
|
||||
parameterWrapper->set(parameters.b);
|
||||
break;
|
||||
case ADDRESS_C:
|
||||
parameterWrapper->set(parameters.c);
|
||||
break;
|
||||
case ADDRESS_GRADIENT:
|
||||
parameterWrapper->set(parameters.gradient);
|
||||
break;
|
||||
default:
|
||||
return INVALID_MATRIX_ID;
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
virtual void resetOldState() {
|
||||
sensorMonitor.setToUnchecked();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /* TEMPERATURESENSOR_H_ */
|
||||
170
fsfw/thermal/ThermalComponent.cpp
Normal file
170
fsfw/thermal/ThermalComponent.cpp
Normal file
@ -0,0 +1,170 @@
|
||||
#include "ThermalComponent.h"
|
||||
|
||||
ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
|
||||
uint8_t domainId, uint32_t temperaturePoolId,
|
||||
uint32_t targetStatePoolId, uint32_t currentStatePoolId,
|
||||
uint32_t requestPoolId, DataSet* dataSet,
|
||||
AbstractTemperatureSensor* sensor,
|
||||
AbstractTemperatureSensor* firstRedundantSensor,
|
||||
AbstractTemperatureSensor* secondRedundantSensor,
|
||||
ThermalModuleIF* thermalModule, Parameters parameters,
|
||||
Priority priority) :
|
||||
CoreComponent(reportingObjectId, domainId, temperaturePoolId,
|
||||
targetStatePoolId, currentStatePoolId, requestPoolId, dataSet,
|
||||
sensor, firstRedundantSensor, secondRedundantSensor,
|
||||
thermalModule,
|
||||
{ parameters.lowerOpLimit, parameters.upperOpLimit,
|
||||
parameters.heaterOn, parameters.hysteresis,
|
||||
parameters.heaterSwitchoff }, priority,
|
||||
ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL), nopParameters(
|
||||
{ parameters.lowerNopLimit, parameters.upperNopLimit }) {
|
||||
}
|
||||
|
||||
ThermalComponent::~ThermalComponent() {
|
||||
}
|
||||
|
||||
ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
|
||||
DataSet mySet;
|
||||
PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
|
||||
&mySet, PoolVariableIF::VAR_READ_WRITE);
|
||||
mySet.read();
|
||||
if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
|
||||
&& (newState != STATE_REQUEST_IGNORE)) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
switch (newState) {
|
||||
case STATE_REQUEST_NON_OPERATIONAL:
|
||||
writableTargetState = newState;
|
||||
mySet.commit(PoolVariableIF::VALID);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
default:
|
||||
return CoreComponent::setTargetState(newState);
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_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(¶meters.lowerOpLimit, &data,
|
||||
&readSize, SerializeIF::Endianness::BIG);
|
||||
SerializeAdapter::deSerialize(¶meters.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,
|
||||
CoreComponent::Parameters parameters, int8_t targetState) {
|
||||
if (temperature < nopParameters.lowerNopLimit) {
|
||||
return OUT_OF_RANGE_LOW;
|
||||
} else {
|
||||
State state = CoreComponent::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 || targetState == STATE_REQUEST_IGNORE) {
|
||||
CoreComponent::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,
|
||||
CoreComponent::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 CoreComponent::getIgnoredState(state);
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t ThermalComponent::getParameter(uint8_t domainId,
|
||||
uint16_t parameterId, ParameterWrapper* parameterWrapper,
|
||||
const ParameterWrapper* newValues, uint16_t startAtIndex) {
|
||||
ReturnValue_t result = CoreComponent::getParameter(domainId, parameterId,
|
||||
parameterWrapper, newValues, startAtIndex);
|
||||
if (result != INVALID_MATRIX_ID) {
|
||||
return result;
|
||||
}
|
||||
switch (parameterId) {
|
||||
case 12:
|
||||
parameterWrapper->set(nopParameters.lowerNopLimit);
|
||||
break;
|
||||
case 13:
|
||||
parameterWrapper->set(nopParameters.upperNopLimit);
|
||||
break;
|
||||
default:
|
||||
return INVALID_MATRIX_ID;
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
53
fsfw/thermal/ThermalComponent.h
Normal file
53
fsfw/thermal/ThermalComponent.h
Normal file
@ -0,0 +1,53 @@
|
||||
#ifndef THERMALCOMPONENT_H_
|
||||
#define THERMALCOMPONENT_H_
|
||||
|
||||
#include "CoreComponent.h"
|
||||
|
||||
class ThermalComponent: public CoreComponent {
|
||||
public:
|
||||
struct Parameters {
|
||||
float lowerNopLimit;
|
||||
float lowerOpLimit;
|
||||
float upperOpLimit;
|
||||
float upperNopLimit;
|
||||
float heaterOn;
|
||||
float hysteresis;
|
||||
float heaterSwitchoff;
|
||||
};
|
||||
struct NopParameters {
|
||||
float lowerNopLimit;
|
||||
float upperNopLimit;
|
||||
};
|
||||
ThermalComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
|
||||
uint32_t targetStatePoolId, uint32_t currentStatePoolId, uint32_t requestPoolId,
|
||||
DataSet *dataSet, AbstractTemperatureSensor *sensor,
|
||||
AbstractTemperatureSensor *firstRedundantSensor,
|
||||
AbstractTemperatureSensor *secondRedundantSensor,
|
||||
ThermalModuleIF *thermalModule, Parameters parameters,
|
||||
Priority priority);
|
||||
virtual ~ThermalComponent();
|
||||
|
||||
ReturnValue_t setTargetState(int8_t newState);
|
||||
|
||||
virtual ReturnValue_t setLimits( const uint8_t* data, uint32_t size);
|
||||
|
||||
virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
|
||||
ParameterWrapper *parameterWrapper,
|
||||
const ParameterWrapper *newValues, uint16_t startAtIndex);
|
||||
|
||||
protected:
|
||||
|
||||
NopParameters nopParameters;
|
||||
|
||||
State getState(float temperature, CoreComponent::Parameters parameters,
|
||||
int8_t targetState);
|
||||
|
||||
virtual void checkLimits(State state);
|
||||
|
||||
virtual HeaterRequest getHeaterRequest(int8_t targetState, float temperature,
|
||||
CoreComponent::Parameters parameters);
|
||||
|
||||
State getIgnoredState(int8_t state);
|
||||
};
|
||||
|
||||
#endif /* THERMALCOMPONENT_H_ */
|
||||
114
fsfw/thermal/ThermalComponentIF.h
Normal file
114
fsfw/thermal/ThermalComponentIF.h
Normal file
@ -0,0 +1,114 @@
|
||||
#ifndef THERMALCOMPONENTIF_H_
|
||||
#define THERMALCOMPONENTIF_H_
|
||||
|
||||
#include "../events/Event.h"
|
||||
#include "../parameters/HasParametersIF.h"
|
||||
#include "../returnvalues/HasReturnvaluesIF.h"
|
||||
#include "../objectmanager/SystemObjectIF.h"
|
||||
|
||||
class ThermalComponentIF : public HasParametersIF {
|
||||
public:
|
||||
|
||||
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_1;
|
||||
static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, SEVERITY::LOW);
|
||||
static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, SEVERITY::LOW);
|
||||
static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, SEVERITY::LOW);
|
||||
static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, SEVERITY::LOW);
|
||||
static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, SEVERITY::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
|
||||
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
|
||||
static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
|
||||
static const ReturnValue_t ABOVE_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF1);
|
||||
static const ReturnValue_t BELOW_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF2);
|
||||
|
||||
enum State {
|
||||
OUT_OF_RANGE_LOW = -2,
|
||||
NON_OPERATIONAL_LOW = -1,
|
||||
OPERATIONAL = 0,
|
||||
NON_OPERATIONAL_HIGH = 1,
|
||||
OUT_OF_RANGE_HIGH = 2,
|
||||
OUT_OF_RANGE_LOW_IGNORED = OUT_OF_RANGE_LOW - 10,
|
||||
NON_OPERATIONAL_LOW_IGNORED = NON_OPERATIONAL_LOW - 10,
|
||||
OPERATIONAL_IGNORED = OPERATIONAL + 10,
|
||||
NON_OPERATIONAL_HIGH_IGNORED = NON_OPERATIONAL_HIGH + 10,
|
||||
OUT_OF_RANGE_HIGH_IGNORED = OUT_OF_RANGE_HIGH + 10,
|
||||
UNKNOWN = 20
|
||||
};
|
||||
|
||||
enum StateRequest {
|
||||
STATE_REQUEST_HEATING = 4,
|
||||
STATE_REQUEST_IGNORE = 3,
|
||||
STATE_REQUEST_OPERATIONAL = 1,
|
||||
STATE_REQUEST_NON_OPERATIONAL = 0
|
||||
};
|
||||
|
||||
/**
|
||||
* The elements are ordered by priority, lowest have highest priority
|
||||
*/
|
||||
enum Priority {
|
||||
SAFE = 0, //!< SAFE
|
||||
IDLE, //!< IDLE
|
||||
PAYLOAD, //!< PAYLOAD
|
||||
NUMBER_OF_PRIORITIES //!< MAX_PRIORITY
|
||||
};
|
||||
|
||||
/**
|
||||
* The elements are ordered by priority, lowest have highest priority
|
||||
*/
|
||||
enum HeaterRequest {
|
||||
HEATER_REQUEST_EMERGENCY_OFF = 0, //!< REQUEST_EMERGENCY_OFF
|
||||
HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
|
||||
HEATER_REQUEST_OFF, //!< REQUEST_OFF
|
||||
HEATER_REQUEST_ON, //!< REQUEST_ON
|
||||
HEATER_DONT_CARE //!< DONT_CARE
|
||||
};
|
||||
|
||||
virtual ~ThermalComponentIF() {
|
||||
|
||||
}
|
||||
|
||||
virtual HeaterRequest performOperation(uint8_t opCode) = 0;
|
||||
|
||||
virtual object_id_t getObjectId() = 0;
|
||||
|
||||
virtual uint8_t getDomainId() const = 0;
|
||||
|
||||
virtual void markStateIgnored() = 0;
|
||||
|
||||
virtual float getLowerOpLimit() = 0;
|
||||
|
||||
virtual ReturnValue_t setTargetState(int8_t state) = 0;
|
||||
|
||||
virtual void setOutputInvalid() = 0;
|
||||
|
||||
static bool isOperational(int8_t state) {
|
||||
return ((state == OPERATIONAL) || (state == OPERATIONAL_IGNORED));
|
||||
}
|
||||
|
||||
static bool isOutOfRange(State state) {
|
||||
return ((state == OUT_OF_RANGE_HIGH)
|
||||
|| (state == OUT_OF_RANGE_HIGH_IGNORED)
|
||||
|| (state == OUT_OF_RANGE_LOW)
|
||||
|| (state == OUT_OF_RANGE_LOW_IGNORED) || (state == UNKNOWN));
|
||||
}
|
||||
|
||||
static bool isNonOperational(State state) {
|
||||
return !isOutOfRange(state);
|
||||
}
|
||||
|
||||
static bool isIgnoredState(State state) {
|
||||
switch (state) {
|
||||
case OUT_OF_RANGE_LOW_IGNORED:
|
||||
case OUT_OF_RANGE_HIGH_IGNORED:
|
||||
case NON_OPERATIONAL_LOW_IGNORED:
|
||||
case NON_OPERATIONAL_HIGH_IGNORED:
|
||||
case OPERATIONAL_IGNORED:
|
||||
case UNKNOWN:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#endif /* THERMALCOMPONENTIF_H_ */
|
||||
288
fsfw/thermal/ThermalModule.cpp
Normal file
288
fsfw/thermal/ThermalModule.cpp
Normal file
@ -0,0 +1,288 @@
|
||||
#include "../monitoring/LimitViolationReporter.h"
|
||||
#include "../monitoring/MonitoringMessageContent.h"
|
||||
#include "ThermalModule.h"
|
||||
|
||||
#include "AbstractTemperatureSensor.h"
|
||||
|
||||
ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
|
||||
uint32_t currentStatePoolId, uint32_t targetStatePoolId,
|
||||
DataSet *dataSet, Parameters parameters,
|
||||
RedundantHeater::Parameters heaterParameters) :
|
||||
oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
|
||||
false), parameters(parameters), moduleTemperature(
|
||||
moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
|
||||
currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
|
||||
targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
|
||||
heater = new RedundantHeater(heaterParameters);
|
||||
}
|
||||
|
||||
ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, DataSet* dataSet) :
|
||||
oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
|
||||
false), parameters( { 0, 0 }), moduleTemperature(
|
||||
moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
|
||||
NULL), currentState(PoolVariableIF::INVALID, dataSet,
|
||||
PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
|
||||
dataSet, PoolVariableIF::VAR_READ) {
|
||||
}
|
||||
|
||||
ThermalModule::~ThermalModule() {
|
||||
delete heater;
|
||||
}
|
||||
|
||||
void ThermalModule::performOperation(uint8_t opCode) {
|
||||
if (heater != NULL) {
|
||||
heater->performOperation(0);
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalModule::performMode(Strategy strategy) {
|
||||
calculateTemperature();
|
||||
|
||||
bool safeOnly = (strategy == ACTIVE_SURVIVAL);
|
||||
ThermalComponentIF::HeaterRequest componentHeaterRequest =
|
||||
letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
|
||||
|
||||
if (heater == NULL) {
|
||||
informComponentsAboutHeaterState(false, NONE);
|
||||
return;
|
||||
}
|
||||
|
||||
bool heating = calculateModuleHeaterRequestAndSetModuleStatus(strategy);
|
||||
|
||||
if (componentHeaterRequest != ThermalComponentIF::HEATER_DONT_CARE) {
|
||||
//Components overwrite the module request.
|
||||
heating = ((componentHeaterRequest
|
||||
== ThermalComponentIF::HEATER_REQUEST_ON)
|
||||
|| (componentHeaterRequest
|
||||
== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
|
||||
}
|
||||
|
||||
bool dual = (strategy == ACTIVE_DUAL);
|
||||
|
||||
if (strategy == PASSIVE) {
|
||||
informComponentsAboutHeaterState(false, NONE);
|
||||
if (oldStrategy != PASSIVE) {
|
||||
heater->set(false, false, true);
|
||||
}
|
||||
} else {
|
||||
if (safeOnly) {
|
||||
informComponentsAboutHeaterState(heating, SAFE);
|
||||
} else {
|
||||
informComponentsAboutHeaterState(heating, ALL);
|
||||
}
|
||||
heater->set(heating, dual);
|
||||
}
|
||||
oldStrategy = strategy;
|
||||
}
|
||||
|
||||
float ThermalModule::getTemperature() {
|
||||
return moduleTemperature;
|
||||
}
|
||||
|
||||
void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
|
||||
sensors.push_back(sensor);
|
||||
}
|
||||
|
||||
void ThermalModule::registerComponent(ThermalComponentIF* component,
|
||||
ThermalComponentIF::Priority priority) {
|
||||
components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
|
||||
}
|
||||
|
||||
void ThermalModule::calculateTemperature() {
|
||||
uint32_t numberOfValidSensors = 0;
|
||||
moduleTemperature = 0;
|
||||
std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
|
||||
for (; iter != sensors.end(); iter++) {
|
||||
if ((*iter)->isValid()) {
|
||||
moduleTemperature = moduleTemperature + (*iter)->getTemperature();
|
||||
numberOfValidSensors++;
|
||||
}
|
||||
}
|
||||
if (numberOfValidSensors != 0) {
|
||||
moduleTemperature = moduleTemperature / numberOfValidSensors;
|
||||
moduleTemperature.setValid(PoolVariableIF::VALID);
|
||||
} else {
|
||||
moduleTemperature = INVALID_TEMPERATURE;
|
||||
moduleTemperature.setValid(PoolVariableIF::INVALID);
|
||||
}
|
||||
}
|
||||
|
||||
ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
|
||||
std::list<ComponentData>::iterator iter = components.begin();
|
||||
for (; iter != components.end(); iter++) {
|
||||
if (iter->component->getObjectId() == objectId) {
|
||||
return iter->component;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
|
||||
bool safeOnly) {
|
||||
ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
|
||||
|
||||
survivalTargetTemp = -999;
|
||||
targetTemp = -999;
|
||||
|
||||
for (uint8_t i = 0; i < ThermalComponentIF::NUMBER_OF_PRIORITIES; i++) {
|
||||
heaterRequests[i] = ThermalComponentIF::HEATER_DONT_CARE;
|
||||
}
|
||||
|
||||
std::list<ComponentData>::iterator iter = components.begin();
|
||||
for (; iter != components.end(); iter++) {
|
||||
updateTargetTemperatures(iter->component,
|
||||
iter->priority == ThermalComponentIF::SAFE);
|
||||
ThermalComponentIF::HeaterRequest request =
|
||||
iter->component->performOperation(0);
|
||||
iter->request = request;
|
||||
if (request != ThermalComponentIF::HEATER_DONT_CARE) {
|
||||
if (request < heaterRequests[iter->priority]) {
|
||||
heaterRequests[iter->priority] = request;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!safeOnly) {
|
||||
for (uint8_t i = ThermalComponentIF::NUMBER_OF_PRIORITIES - 1; i > 0;
|
||||
i--) {
|
||||
if (heaterRequests[i - 1] == ThermalComponentIF::HEATER_DONT_CARE) {
|
||||
heaterRequests[i - 1] = heaterRequests[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
return heaterRequests[0];
|
||||
}
|
||||
|
||||
void ThermalModule::informComponentsAboutHeaterState(bool heaterIsOn,
|
||||
Informee whomToInform) {
|
||||
std::list<ComponentData>::iterator iter = components.begin();
|
||||
for (; iter != components.end(); iter++) {
|
||||
switch (whomToInform) {
|
||||
case ALL:
|
||||
break;
|
||||
case SAFE:
|
||||
if (!(iter->priority == ThermalComponentIF::SAFE)) {
|
||||
iter->component->markStateIgnored();
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
case NONE:
|
||||
iter->component->markStateIgnored();
|
||||
continue;
|
||||
}
|
||||
|
||||
if (heaterIsOn) {
|
||||
if ((iter->request
|
||||
== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_OFF)
|
||||
|| (iter->request == ThermalComponentIF::HEATER_REQUEST_OFF)) {
|
||||
iter->component->markStateIgnored();
|
||||
}
|
||||
} else {
|
||||
if ((iter->request
|
||||
== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON)
|
||||
|| (iter->request == ThermalComponentIF::HEATER_REQUEST_ON)) {
|
||||
iter->component->markStateIgnored();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
|
||||
if (heater != NULL) {
|
||||
heater->setPowerSwitcher(powerSwitch);
|
||||
}
|
||||
|
||||
std::list<ComponentData>::iterator iter = components.begin();
|
||||
for (; iter != components.end(); iter++) {
|
||||
float componentLowerOpLimit = iter->component->getLowerOpLimit();
|
||||
if (iter->priority == ThermalComponentIF::SAFE) {
|
||||
if (componentLowerOpLimit > survivalTargetTemp) {
|
||||
survivalTargetTemp = componentLowerOpLimit;
|
||||
}
|
||||
} else {
|
||||
if (componentLowerOpLimit > targetTemp) {
|
||||
targetTemp = componentLowerOpLimit;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (survivalTargetTemp > targetTemp) {
|
||||
targetTemp = survivalTargetTemp;
|
||||
}
|
||||
}
|
||||
|
||||
bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
|
||||
Strategy strategy) {
|
||||
currentState.setValid(PoolVariableIF::VALID);
|
||||
if (moduleTemperature == INVALID_TEMPERATURE) {
|
||||
currentState = UNKNOWN;
|
||||
return false;
|
||||
}
|
||||
|
||||
float limit = targetTemp;
|
||||
bool heaterRequest = false;
|
||||
if (strategy == ACTIVE_SURVIVAL) {
|
||||
limit = survivalTargetTemp;
|
||||
}
|
||||
|
||||
if (moduleTemperature >= limit) {
|
||||
currentState = OPERATIONAL;
|
||||
} else {
|
||||
currentState = NON_OPERATIONAL;
|
||||
}
|
||||
|
||||
limit += parameters.heaterOn;
|
||||
|
||||
if (heating) {
|
||||
limit += parameters.hysteresis;
|
||||
}
|
||||
|
||||
if (targetState == STATE_REQUEST_HEATING) {
|
||||
if (moduleTemperature < limit) {
|
||||
heaterRequest = true;
|
||||
} else {
|
||||
heaterRequest = false;
|
||||
}
|
||||
}
|
||||
|
||||
heating = heaterRequest;
|
||||
|
||||
return heaterRequest;
|
||||
}
|
||||
|
||||
void ThermalModule::setHeating(bool on) {
|
||||
DataSet mySet;
|
||||
PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
|
||||
&mySet, PoolVariableIF::VAR_WRITE);
|
||||
if (on) {
|
||||
writableTargetState = STATE_REQUEST_HEATING;
|
||||
} else {
|
||||
writableTargetState = STATE_REQUEST_PASSIVE;
|
||||
}
|
||||
mySet.commit(PoolVariableIF::VALID);
|
||||
}
|
||||
|
||||
void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
|
||||
bool isSafe) {
|
||||
if (isSafe) {
|
||||
if (component->getLowerOpLimit() > survivalTargetTemp) {
|
||||
survivalTargetTemp = component->getLowerOpLimit();
|
||||
}
|
||||
} else {
|
||||
if (component->getLowerOpLimit() > targetTemp) {
|
||||
targetTemp = component->getLowerOpLimit();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalModule::setOutputInvalid() {
|
||||
moduleTemperature = INVALID_TEMPERATURE;
|
||||
moduleTemperature.setValid(PoolVariableIF::INVALID);
|
||||
currentState.setValid(PoolVariableIF::INVALID);
|
||||
std::list<ComponentData>::iterator iter = components.begin();
|
||||
for (; iter != components.end(); iter++) {
|
||||
iter->component->setOutputInvalid();
|
||||
}
|
||||
if (heater != NULL) {
|
||||
heater->set(false,true);
|
||||
}
|
||||
}
|
||||
92
fsfw/thermal/ThermalModule.h
Normal file
92
fsfw/thermal/ThermalModule.h
Normal file
@ -0,0 +1,92 @@
|
||||
#ifndef THERMALMODULE_H_
|
||||
#define THERMALMODULE_H_
|
||||
|
||||
#include "../datapool/DataSet.h"
|
||||
#include "../datapool/PoolVariable.h"
|
||||
#include "../devicehandlers/HealthDevice.h"
|
||||
#include "../events/EventReportingProxyIF.h"
|
||||
#include "ThermalModuleIF.h"
|
||||
#include <list>
|
||||
#include "tcsDefinitions.h"
|
||||
#include "RedundantHeater.h"
|
||||
class PowerSwitchIF;
|
||||
|
||||
class ThermalModule: public ThermalModuleIF {
|
||||
friend class ThermalController;
|
||||
public:
|
||||
struct Parameters {
|
||||
float heaterOn;
|
||||
float hysteresis;
|
||||
};
|
||||
|
||||
ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
|
||||
uint32_t targetStatePoolId, DataSet *dataSet, Parameters parameters,
|
||||
RedundantHeater::Parameters heaterParameters);
|
||||
|
||||
ThermalModule(uint32_t moduleTemperaturePoolId, DataSet *dataSet);
|
||||
|
||||
virtual ~ThermalModule();
|
||||
|
||||
void performOperation(uint8_t opCode);
|
||||
|
||||
void performMode(Strategy strategy);
|
||||
|
||||
float getTemperature();
|
||||
|
||||
void registerSensor(AbstractTemperatureSensor *sensor);
|
||||
|
||||
void registerComponent(ThermalComponentIF *component,
|
||||
ThermalComponentIF::Priority priority);
|
||||
|
||||
ThermalComponentIF *findComponent(object_id_t objectId);
|
||||
|
||||
void initialize(PowerSwitchIF* powerSwitch);
|
||||
|
||||
void setHeating(bool on);
|
||||
|
||||
virtual void setOutputInvalid();
|
||||
|
||||
protected:
|
||||
enum Informee {
|
||||
ALL, SAFE, NONE
|
||||
};
|
||||
|
||||
struct ComponentData {
|
||||
ThermalComponentIF *component;
|
||||
ThermalComponentIF::Priority priority;
|
||||
ThermalComponentIF::HeaterRequest request;
|
||||
};
|
||||
|
||||
Strategy oldStrategy;
|
||||
|
||||
float survivalTargetTemp;
|
||||
|
||||
float targetTemp;
|
||||
|
||||
bool heating;
|
||||
|
||||
Parameters parameters;
|
||||
|
||||
db_float_t moduleTemperature;
|
||||
|
||||
RedundantHeater *heater;
|
||||
|
||||
db_int8_t currentState;
|
||||
db_int8_t targetState;
|
||||
|
||||
std::list<AbstractTemperatureSensor *> sensors;
|
||||
std::list<ComponentData> components;
|
||||
|
||||
void calculateTemperature();
|
||||
|
||||
ThermalComponentIF::HeaterRequest letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly);
|
||||
|
||||
void informComponentsAboutHeaterState(bool heaterIsOn,
|
||||
Informee whomToInform);
|
||||
|
||||
bool calculateModuleHeaterRequestAndSetModuleStatus(Strategy strategy);
|
||||
|
||||
void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
|
||||
};
|
||||
|
||||
#endif /* THERMALMODULE_H_ */
|
||||
45
fsfw/thermal/ThermalModuleIF.h
Normal file
45
fsfw/thermal/ThermalModuleIF.h
Normal file
@ -0,0 +1,45 @@
|
||||
#ifndef THERMALMODULEIF_H_
|
||||
#define THERMALMODULEIF_H_
|
||||
|
||||
#include "ThermalComponentIF.h"
|
||||
class AbstractTemperatureSensor;
|
||||
|
||||
class ThermalModuleIF{
|
||||
public:
|
||||
enum Strategy {
|
||||
PASSIVE = 0, ACTIVE_SURVIVAL = 1, ACTIVE_SINGLE = 2, ACTIVE_DUAL = 3,
|
||||
};
|
||||
|
||||
enum StateRequest {
|
||||
STATE_REQUEST_HEATING = 1, STATE_REQUEST_PASSIVE = 0
|
||||
};
|
||||
|
||||
enum State {
|
||||
NON_OPERATIONAL = 0, OPERATIONAL = 1, UNKNOWN = 2
|
||||
};
|
||||
|
||||
static constexpr float INVALID_TEMPERATURE = 999;
|
||||
|
||||
virtual ~ThermalModuleIF() {
|
||||
|
||||
}
|
||||
|
||||
virtual void performOperation(uint8_t opCode) = 0;
|
||||
|
||||
virtual void performMode(Strategy strategy) = 0;
|
||||
|
||||
virtual float getTemperature() = 0;
|
||||
|
||||
virtual void registerSensor(AbstractTemperatureSensor *sensor) = 0;
|
||||
|
||||
virtual void registerComponent(ThermalComponentIF *component,
|
||||
ThermalComponentIF::Priority priority) = 0;
|
||||
|
||||
virtual ThermalComponentIF *findComponent(object_id_t objectId) = 0;
|
||||
|
||||
virtual void setHeating(bool on) = 0;
|
||||
|
||||
virtual void setOutputInvalid() = 0;
|
||||
};
|
||||
|
||||
#endif /* THERMALMODULEIF_H_ */
|
||||
68
fsfw/thermal/ThermalMonitor.cpp
Normal file
68
fsfw/thermal/ThermalMonitor.cpp
Normal file
@ -0,0 +1,68 @@
|
||||
#include "ThermalMonitor.h"
|
||||
#include "ThermalComponentIF.h"
|
||||
#include "../monitoring/MonitoringIF.h"
|
||||
ThermalMonitor::~ThermalMonitor() {
|
||||
}
|
||||
|
||||
void ThermalMonitor::sendTransitionEvent(float currentValue,
|
||||
ReturnValue_t state) {
|
||||
switch (state) {
|
||||
case MonitoringIF::BELOW_LOW_LIMIT:
|
||||
EventManagerIF::triggerEvent(reportingId,
|
||||
ThermalComponentIF::COMPONENT_TEMP_OOL_LOW, state);
|
||||
break;
|
||||
case MonitoringIF::ABOVE_HIGH_LIMIT:
|
||||
EventManagerIF::triggerEvent(reportingId,
|
||||
ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH, state);
|
||||
break;
|
||||
case ThermalComponentIF::BELOW_OPERATIONAL_LIMIT:
|
||||
EventManagerIF::triggerEvent(reportingId,
|
||||
ThermalComponentIF::COMPONENT_TEMP_LOW, state);
|
||||
break;
|
||||
case ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT:
|
||||
EventManagerIF::triggerEvent(reportingId,
|
||||
ThermalComponentIF::COMPONENT_TEMP_HIGH, state);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
bool ThermalMonitor::isAboveHighLimit() {
|
||||
if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t ThermalMonitor::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
|
||||
float upperLimit, bool componentIsOperational) {
|
||||
if (ThermalComponentIF::isIgnoredState(state)) {
|
||||
setToUnchecked();
|
||||
return MonitoringIF::UNCHECKED;
|
||||
}
|
||||
switch (state) {
|
||||
case ThermalComponentIF::OUT_OF_RANGE_LOW:
|
||||
return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample, lowerLimit);
|
||||
case ThermalComponentIF::NON_OPERATIONAL_LOW:
|
||||
if (componentIsOperational) {
|
||||
return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT, sample, lowerLimit);
|
||||
} else {
|
||||
return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
|
||||
}
|
||||
case ThermalComponentIF::OPERATIONAL:
|
||||
return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
|
||||
case ThermalComponentIF::NON_OPERATIONAL_HIGH:
|
||||
if (componentIsOperational) {
|
||||
return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT, sample, upperLimit);
|
||||
} else {
|
||||
return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
|
||||
}
|
||||
case ThermalComponentIF::OUT_OF_RANGE_HIGH:
|
||||
return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample, upperLimit);
|
||||
default:
|
||||
//Never reached, all states covered.
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
}
|
||||
23
fsfw/thermal/ThermalMonitor.h
Normal file
23
fsfw/thermal/ThermalMonitor.h
Normal file
@ -0,0 +1,23 @@
|
||||
#ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_
|
||||
#define FRAMEWORK_THERMAL_THERMALMONITOR_H_
|
||||
|
||||
#include "../monitoring/MonitorReporter.h"
|
||||
#include "ThermalComponentIF.h"
|
||||
|
||||
class ThermalMonitor: public MonitorReporter<float> {
|
||||
public:
|
||||
template<typename ... Args>
|
||||
ThermalMonitor(Args ... args) :
|
||||
MonitorReporter<float>(std::forward<Args>(args)...) {
|
||||
}
|
||||
~ThermalMonitor();
|
||||
ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
|
||||
float lowerLimit, float upperLimit, bool componentIsOperational = true);
|
||||
|
||||
bool isAboveHighLimit();
|
||||
protected:
|
||||
virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
|
||||
|
||||
};
|
||||
|
||||
#endif /* FRAMEWORK_THERMAL_THERMALMONITOR_H_ */
|
||||
8
fsfw/thermal/tcsDefinitions.h
Normal file
8
fsfw/thermal/tcsDefinitions.h
Normal file
@ -0,0 +1,8 @@
|
||||
#ifndef TCSDEFINITIONS_H_
|
||||
#define TCSDEFINITIONS_H_
|
||||
|
||||
|
||||
static const uint32_t INVALID_TEMPERATURE = 999;
|
||||
|
||||
|
||||
#endif /* TCSDEFINITIONS_H_ */
|
||||
Reference in New Issue
Block a user