eive/fsfw
eive/fsfw
15
1
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests Releases 1 Wiki Activity

thermal module replacements

Browse Source
This commit is contained in:
Robin Müller 2020-11-30 16:25:09 +01:00
parent 4bb9dd816e
commit f581b37fcf
7 changed files with 109 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
power/Fuse.h
View File

@ -4,9 +4,6 @@
#include "PowerComponentIF.h"
#include "PowerSwitchIF.h"
#include "../datapoolglob/GlobalDataSet.h"
#include "../datapoolglob/GlobalPoolVariable.h"
#include "../datapoolglob/PIDReader.h"
#include "../devicehandlers/HealthDevice.h"
#include "../monitoring/AbsLimitMonitor.h"
#include "../returnvalues/HasReturnvaluesIF.h"

3
power/PowerSensor.h
View File

@ -1,9 +1,6 @@
#ifndef FSFW_POWER_POWERSENSOR_H_
#define FSFW_POWER_POWERSENSOR_H_
#include "../datapoolglob/GlobalDataSet.h"
#include "../datapoolglob/GlobalPoolVariable.h"
#include "../datapoolglob/PIDReader.h"
#include "../datapoollocal/StaticLocalDataSet.h"
#include "../devicehandlers/HealthDevice.h"
#include "../monitoring/LimitMonitor.h"

33
thermal/ThermalComponent.cpp
View File

@ -22,22 +22,23 @@ ThermalComponent::~ThermalComponent() {
}
ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
GlobDataSet mySet;
gp_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 ThermalComponentCore::setTargetState(newState);
}
// GlobDataSet mySet;
// gp_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 ThermalComponentCore::setTargetState(newState);
// }
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {

39
thermal/ThermalComponentCore.cpp
View File

@ -96,25 +96,26 @@ float ThermalComponentCore::getLowerOpLimit() {
ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
GlobDataSet mySet;
gp_uint8_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);
// GlobDataSet mySet;
// gp_uint8_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;
return HasReturnvaluesIF::RETURN_OK;
}

2
thermal/ThermalComponentCore.h
View File

@ -6,8 +6,6 @@
#include "AbstractTemperatureSensor.h"
#include "ThermalModule.h"
//#include "../datapoolglob/GlobalDataSet.h"
//#include "../datapoolglob/GlobalPoolVariable.h"
#include "../datapoollocal/LocalPoolVariable.h"
/**

84
thermal/ThermalModule.cpp
View File

@ -1,28 +1,31 @@
#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,
GlobDataSet *dataSet, Parameters parameters,
#include "../monitoring/LimitViolationReporter.h"
#include "../monitoring/MonitoringMessageContent.h"
ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
gp_id_t currentStatePoolId, gp_id_t targetStatePoolId,
LocalPoolDataSetBase *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) {
oldStrategy(ACTIVE_SINGLE), 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, GlobDataSet* 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(gp_id_t moduleTemperaturePoolId,
LocalPoolDataSetBase* dataSet) :
oldStrategy(ACTIVE_SINGLE), parameters( { 0, 0 }),
moduleTemperature(moduleTemperaturePoolId, dataSet,
PoolVariableIF::VAR_WRITE),
currentState(gp_id_t(), dataSet,
PoolVariableIF::VAR_WRITE),
targetState(gp_id_t(), dataSet,
PoolVariableIF::VAR_READ) {
}
ThermalModule::~ThermalModule() {
@ -30,7 +33,7 @@ ThermalModule::~ThermalModule() {
}
void ThermalModule::performOperation(uint8_t opCode) {
if (heater != NULL) {
if (heater != nullptr) {
heater->performOperation(0);
}
}
@ -42,7 +45,7 @@ void ThermalModule::performMode(Strategy strategy) {
ThermalComponentIF::HeaterRequest componentHeaterRequest =
letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
if (heater == NULL) {
if (heater == nullptr) {
informComponentsAboutHeaterState(false, NONE);
return;
}
@ -53,8 +56,8 @@ void ThermalModule::performMode(Strategy strategy) {
//Components overwrite the module request.
heating = ((componentHeaterRequest
== ThermalComponentIF::HEATER_REQUEST_ON)
|| (componentHeaterRequest
== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
or (componentHeaterRequest
== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
}
bool dual = (strategy == ACTIVE_DUAL);
@ -76,7 +79,7 @@ void ThermalModule::performMode(Strategy strategy) {
}
float ThermalModule::getTemperature() {
return moduleTemperature;
return moduleTemperature.value;
}
void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
@ -85,7 +88,8 @@ void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
void ThermalModule::registerComponent(ThermalComponentIF* component,
ThermalComponentIF::Priority priority) {
components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
components.push_back(ComponentData( { component, priority,
ThermalComponentIF::HEATER_DONT_CARE }));
}
void ThermalModule::calculateTemperature() {
@ -94,12 +98,13 @@ void ThermalModule::calculateTemperature() {
std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
for (; iter != sensors.end(); iter++) {
if ((*iter)->isValid()) {
moduleTemperature = moduleTemperature + (*iter)->getTemperature();
moduleTemperature = moduleTemperature.value +
(*iter)->getTemperature();
numberOfValidSensors++;
}
}
if (numberOfValidSensors != 0) {
moduleTemperature = moduleTemperature / numberOfValidSensors;
moduleTemperature = moduleTemperature.value / numberOfValidSensors;
moduleTemperature.setValid(PoolVariableIF::VALID);
} else {
moduleTemperature = INVALID_TEMPERATURE;
@ -117,9 +122,10 @@ ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
return NULL;
}
ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
bool safeOnly) {
ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
ThermalComponentIF::HeaterRequest
ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly) {
ThermalComponentIF::HeaterRequest
heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
survivalTargetTemp = -999;
targetTemp = -999;
@ -224,7 +230,7 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
limit = survivalTargetTemp;
}
if (moduleTemperature >= limit) {
if (moduleTemperature.value >= limit) {
currentState = OPERATIONAL;
} else {
currentState = NON_OPERATIONAL;
@ -250,15 +256,15 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
}
void ThermalModule::setHeating(bool on) {
GlobDataSet mySet;
gp_int8_t writableTargetState(targetState.getDataPoolId(),
&mySet, PoolVariableIF::VAR_WRITE);
if (on) {
writableTargetState = STATE_REQUEST_HEATING;
} else {
writableTargetState = STATE_REQUEST_PASSIVE;
}
mySet.commit(PoolVariableIF::VALID);
// GlobDataSet mySet;
// gp_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,

46
thermal/ThermalModule.h
View File

@ -1,14 +1,20 @@
#ifndef THERMALMODULE_H_
#define THERMALMODULE_H_
#ifndef FSFW_THERMAL_THERMALMODULE_H_
#define FSFW_THERMAL_THERMALMODULE_H_
#include "../datapoolglob/GlobalDataSet.h"
#include "../datapoolglob/GlobalPoolVariable.h"
#include "../devicehandlers/HealthDevice.h"
#include "../events/EventReportingProxyIF.h"
#include "ThermalModuleIF.h"
#include <list>
#include "tcsDefinitions.h"
#include "RedundantHeater.h"
//#include "../datapoolglob/GlobalDataSet.h"
//#include "../datapoolglob/GlobalPoolVariable.h"
#include "../datapoollocal/LocalPoolDataSetBase.h"
#include "../datapoollocal/LocalPoolVariable.h"
#include "../devicehandlers/HealthDevice.h"
#include "../events/EventReportingProxyIF.h"
#include <list>
class PowerSwitchIF;
/**
@ -22,11 +28,12 @@ public:
float hysteresis;
};
ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
RedundantHeater::Parameters heaterParameters);
ThermalModule(gp_id_t moduleTemperaturePoolId, gp_id_t currentStatePoolId,
gp_id_t targetStatePoolId, LocalPoolDataSetBase *dataSet,
Parameters parameters, RedundantHeater::Parameters heaterParameters);
ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
ThermalModule(gp_id_t moduleTemperaturePoolId,
LocalPoolDataSetBase *dataSet);
virtual ~ThermalModule();
@ -62,20 +69,21 @@ protected:
Strategy oldStrategy;
float survivalTargetTemp;
float survivalTargetTemp = 0.0;
float targetTemp;
float targetTemp = 0.0;
bool heating;
bool heating = false;
Parameters parameters;
gp_float_t moduleTemperature;
lp_var_t<float> moduleTemperature;
//gp_float_t moduleTemperature;
RedundantHeater *heater;
RedundantHeater *heater = nullptr;
gp_int8_t currentState;
gp_int8_t targetState;
lp_var_t<int8_t> currentState;
lp_var_t<int8_t> targetState;
std::list<AbstractTemperatureSensor *> sensors;
std::list<ComponentData> components;
@ -92,4 +100,4 @@ protected:
void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
};
#endif /* THERMALMODULE_H_ */
#endif /* FSFW_THERMAL_THERMALMODULE_H_ */