thermal update

thermal/AbstractTemperatureSensor.cpp

@@ -44,19 +44,19 @@ ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
 }
 
 void AbstractTemperatureSensor::handleCommandQueue() {
-	CommandMessage message;
+	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
-		result = parameterHelper.handleParameterMessage(&message);
+		result = parameterHelper.handleParameterMessage(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
-		message.setToUnknownCommand();
+		command.setToUnknownCommand();
-		commandQueue->reply(&message);
+		commandQueue->reply(&command);
 	}
 }
 

thermal/AbstractTemperatureSensor.h

@@ -10,6 +10,16 @@
 #include "ThermalModuleIF.h"
 #include "tcsDefinitions.h"
 
+/**
+ * @defgroup thermal Thermal Components
+ * @brief Contains all components related to thermal tasks (sensors, heaters)
+ */
+
+/**
+ * @brief Base class for Temperature Sensor, implements all important interfaces.
+ *        Please use the TemperatureSensor class to implement the actual sensors.
+ * @ingroup thermal
+ */
 class AbstractTemperatureSensor: public HasHealthIF,
 		public SystemObject,
 		public ExecutableObjectIF,

thermal/AcceptsThermalMessagesIF.h

@@ -0,0 +1,22 @@
+/**
+ * \file AcceptsThermalMessagesIF.h
+ *
+ * \date 16.02.2020
+ */
+
+#ifndef FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
+#define FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
+#include "../ipc/MessageQueueSenderIF.h"
+
+class AcceptsThermalMessagesIF {
+public:
+
+	/**
+	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~AcceptsThermalMessagesIF() { }
+
+	virtual MessageQueueId_t getReceptionQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_ */

thermal/Heater.cpp

@@ -279,14 +279,14 @@ ReturnValue_t Heater::initialize() {
 }
 
 void Heater::handleQueue() {
-	CommandMessage message;
+	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
-		parameterHelper.handleParameterMessage(&message);
+		parameterHelper.handleParameterMessage(&command);
 	}
 }
 
@@ -301,7 +301,7 @@ ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
 		parameterWrapper->set(heaterOnCountdown.timeout);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }

thermal/RedundantHeater.h

@@ -1,7 +1,7 @@
 #ifndef REDUNDANTHEATER_H_
 #define REDUNDANTHEATER_H_
 
-#include "Heater.h"
+#include "../thermal/Heater.h"
 
 class RedundantHeater {
 public:
@@ -10,15 +10,14 @@ public:
 		Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
 				uint8_t switch0Heater0, uint8_t switch1Heater0,
 				uint8_t switch0Heater1, uint8_t switch1Heater1) :
-				objectIdHeater0(objectIdHeater0), objectIdHeater1(
+				objectIdHeater0(objectIdHeater0), objectIdHeater1(objectIdHeater1),
-						objectIdHeater1), switch0Heater0(switch0Heater0), switch1Heater0(
+				switch0Heater0(switch0Heater0),switch1Heater0(switch1Heater0),
-						switch1Heater0), switch0Heater1(switch0Heater1), switch1Heater1(
+				switch0Heater1(switch0Heater1), switch1Heater1(switch1Heater1) {
-						switch1Heater1) {
 		}
 
 		Parameters() :
-				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0), switch1Heater0(
+				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0),
-						0), switch0Heater1(0), switch1Heater1(0) {
+				switch1Heater0(0), switch0Heater1(0), switch1Heater1(0) {
 		}
 
 		uint32_t objectIdHeater0;

thermal/TemperatureSensor.h

@@ -1,40 +1,101 @@
 #ifndef TEMPERATURESENSOR_H_
 #define TEMPERATURESENSOR_H_
 
-#include "../datapool/DataSet.h"
+#include "../thermal/AbstractTemperatureSensor.h"
-#include "AbstractTemperatureSensor.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../monitoring/LimitMonitor.h"
 
-template<typename T>
+/**
+ * @brief 	This building block handles non-linear value conversion and
+ * 			range checks for analog temperature sensors.
+ * @details This class can be used to perform all necessary tasks for temperature sensors.
+ *          A sensor can be instantiated by calling the constructor.
+ *          The temperature is calculated from an input value with
+ *			the calculateOutputTemperature() function. Range checking and
+ *			limit monitoring is performed automatically.
+ *			The inputType specifies the type of the raw input while the
+ *			limitType specifies the type of the upper and lower limit to check against.
+ * @ingroup thermal
+ */
+
+template<typename inputType, typename limitType = inputType>
 class TemperatureSensor: public AbstractTemperatureSensor {
 public:
+	/**
+	 * This structure contains parameters required for range checking
+	 * and the conversion from the input value to the output temperature.
+	 * a, b and c can be any parameters required to calculate the output
+	 * temperature from the input value, depending on the formula used.
+	 *
+	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
+	 *
+	 * The lower and upper limits can be specified in any type, for example float for C values
+	 * or any other type for raw values.
+	 */
 	struct Parameters {
 		float a;
 		float b;
 		float c;
-		T lowerLimit;
+		limitType lowerLimit;
-		T upperLimit;
+		limitType upperLimit;
-		float gradient;
+		float maxGradient;
 	};
+
+	/**
+	 * Forward declaration for explicit instantiation of used parameters.
+	 */
 	struct UsedParameters {
 		UsedParameters(Parameters parameters) :
-				a(parameters.a), b(parameters.b), c(parameters.c), gradient(
+			a(parameters.a), b(parameters.b), c(parameters.c),
-						parameters.gradient) {
+			gradient(parameters.maxGradient) {}
-		}
 		float a;
 		float b;
 		float c;
 		float gradient;
 	};
 
-	static const uint16_t ADDRESS_A = 0;
+	/**
-	static const uint16_t ADDRESS_B = 1;
+	 * Instantiate Temperature Sensor Object.
-	static const uint16_t ADDRESS_C = 2;
+	 * @param setObjectid objectId of the sensor object
-	static const uint16_t ADDRESS_GRADIENT = 3;
+	 * @param inputValue Input value which is converted to a temperature
+	 * @param poolVariable Pool Variable to store the temperature value
+	 * @param vectorIndex Vector Index for the sensor monitor
+	 * @param parameters Calculation parameters, temperature limits, gradient limit
+	 * @param datapoolId Datapool ID of the output temperature
+	 * @param outputSet Output dataset for the output temperature to fetch it with read()
+	 * @param thermalModule respective thermal module, if it has one
+	 */
+	TemperatureSensor(object_id_t setObjectid,
+			inputType *inputValue, PoolVariableIF *poolVariable,
+			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
+			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
+			inputValue(inputValue), poolVariable(poolVariable),
+			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
+			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
+				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
+				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
+			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
+	}
+
+
+protected:
+	/**
+	 * This formula is used to calculate the temperature from an input value
+	 * with an arbitrary type.
+	 * A default implementation is provided but can be replaced depending
+	 * on the required calculation.
+	 * @param inputTemperature
+	 * @return
+	 */
+	virtual float calculateOutputTemperature(inputType inputValue) {
+		return parameters.a * inputValue * inputValue
+				+ parameters.b * inputValue + parameters.c;
+	}
 
-	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;
@@ -47,22 +108,17 @@ protected:
 
 	UsedParameters parameters;
 
-	T *inputTemperature;
+	inputType * inputValue;
 
 	PoolVariableIF *poolVariable;
 
-	PoolVariable<float> outputTemperature;
+	gp_float_t outputTemperature;
 
-	LimitMonitor<T> sensorMonitor;
+	LimitMonitor<limitType> 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())) {
@@ -70,7 +126,7 @@ protected:
 			return;
 		}
 
-		outputTemperature = calculateOutputTemperature(*inputTemperature);
+		outputTemperature = calculateOutputTemperature(*inputValue);
 		outputTemperature.setValid(PoolVariableIF::VALID);
 
 		timeval uptime;
@@ -78,7 +134,7 @@ protected:
 
 		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.
+			//But this would require storing the maxGradient in DP and quite some overhead.
 			//The concept of delta limits is a bit strange anyway.
 			float deltaTime;
 			float deltaTemp;
@@ -96,8 +152,8 @@ protected:
 			}
 		}
 
-		//Check is done against raw limits. SHOULDDO: Why? Using °C would be more easy to handle.
+		//Check is done against raw limits. SHOULDDO: Why? Using <EFBFBD>C would be more easy to handle.
-		sensorMonitor.doCheck(*inputTemperature);
+		sensorMonitor.doCheck(outputTemperature.value);
 
 		if (sensorMonitor.isOutOfLimits()) {
 			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
@@ -110,23 +166,6 @@ protected:
 	}
 
 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;
 	}
@@ -135,6 +174,15 @@ public:
 		return outputTemperature.isValid();
 	}
 
+	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;
+
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) {
@@ -160,7 +208,7 @@ public:
 			parameterWrapper->set(parameters.gradient);
 			break;
 		default:
-			return INVALID_MATRIX_ID;
+			return INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}

thermal/ThermalComponent.cpp

@@ -1,48 +1,46 @@
 #include "ThermalComponent.h"
 
 ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
-		uint8_t domainId, uint32_t temperaturePoolId,
+		uint8_t domainId, gp_id_t temperaturePoolId,
-		uint32_t targetStatePoolId, uint32_t currentStatePoolId,
+		gp_id_t targetStatePoolId, gp_id_t currentStatePoolId,
-		uint32_t requestPoolId, DataSet* dataSet,
+		gp_id_t requestPoolId, LocalPoolDataSetBase* dataSet,
 		AbstractTemperatureSensor* sensor,
 		AbstractTemperatureSensor* firstRedundantSensor,
 		AbstractTemperatureSensor* secondRedundantSensor,
 		ThermalModuleIF* thermalModule, Parameters parameters,
 		Priority priority) :
-		CoreComponent(reportingObjectId, domainId, temperaturePoolId,
+		ThermalComponentCore(reportingObjectId, domainId, temperaturePoolId,
 				targetStatePoolId, currentStatePoolId, requestPoolId, dataSet,
-				sensor, firstRedundantSensor, secondRedundantSensor,
-				thermalModule,
 				{ parameters.lowerOpLimit, parameters.upperOpLimit,
-						parameters.heaterOn, parameters.hysteresis,
+				parameters.heaterOn, parameters.hysteresis,
-						parameters.heaterSwitchoff }, priority,
+				parameters.heaterSwitchoff },
-				ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL), nopParameters(
+				ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL),
-				{ parameters.lowerNopLimit, parameters.upperNopLimit }) {
+		nopParameters({ parameters.lowerNopLimit, parameters.upperNopLimit }) {
 }
 
 ThermalComponent::~ThermalComponent() {
 }
 
 ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
-	DataSet mySet;
+	targetState.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
+	targetState.read();
-			&mySet, PoolVariableIF::VAR_READ_WRITE);
+	if ((targetState == STATE_REQUEST_OPERATIONAL)
-	mySet.read();
+			and (newState != STATE_REQUEST_IGNORE)) {
-	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
-			&& (newState != STATE_REQUEST_IGNORE)) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	switch (newState) {
 	case STATE_REQUEST_NON_OPERATIONAL:
-		writableTargetState = newState;
+		targetState = newState;
-		mySet.commit(PoolVariableIF::VALID);
+		targetState.setValid(true);
+		targetState.commit(PoolVariableIF::VALID);
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
-		return CoreComponent::setTargetState(newState);
+		return ThermalComponentCore::setTargetState(newState);
 	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
+ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
 	if (size != 4 * sizeof(parameters.lowerOpLimit)) {
 		return MonitoringIF::INVALID_SIZE;
 	}
@@ -59,11 +57,11 @@ ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
 }
 
 ThermalComponentIF::State ThermalComponent::getState(float temperature,
-		CoreComponent::Parameters parameters, int8_t targetState) {
+		ThermalComponentCore::Parameters parameters, int8_t targetState) {
 	if (temperature < nopParameters.lowerNopLimit) {
 		return OUT_OF_RANGE_LOW;
 	} else {
-		State state = CoreComponent::getState(temperature, parameters,
+		State state = ThermalComponentCore::getState(temperature, parameters,
 				targetState);
 		if (state != NON_OPERATIONAL_HIGH
 				&& state != NON_OPERATIONAL_HIGH_IGNORED) {
@@ -80,18 +78,19 @@ ThermalComponentIF::State ThermalComponent::getState(float temperature,
 }
 
 void ThermalComponent::checkLimits(ThermalComponentIF::State state) {
-	if (targetState == STATE_REQUEST_OPERATIONAL || targetState == STATE_REQUEST_IGNORE) {
+	if ((targetState == STATE_REQUEST_OPERATIONAL) or
-		CoreComponent::checkLimits(state);
+			(targetState == STATE_REQUEST_IGNORE)) {
+		ThermalComponentCore::checkLimits(state);
 		return;
 	}
-	//If component is not operational, it checks the NOP limits.
+	// 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) {
+		ThermalComponentCore::Parameters parameters) {
 	if (targetState == STATE_REQUEST_IGNORE) {
 		isHeating = false;
 		return HEATER_DONT_CARE;
@@ -144,16 +143,16 @@ ThermalComponentIF::State ThermalComponent::getIgnoredState(int8_t state) {
 	case OUT_OF_RANGE_HIGH_IGNORED:
 		return OUT_OF_RANGE_HIGH_IGNORED;
 	default:
-		return CoreComponent::getIgnoredState(state);
+		return ThermalComponentCore::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,
+	ReturnValue_t result = ThermalComponentCore::getParameter(domainId, parameterId,
 			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_MATRIX_ID) {
+	if (result != INVALID_IDENTIFIER_ID) {
 		return result;
 	}
 	switch (parameterId) {
@@ -164,7 +163,7 @@ ReturnValue_t ThermalComponent::getParameter(uint8_t domainId,
 		parameterWrapper->set(nopParameters.upperNopLimit);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }

thermal/ThermalComponent.h

@@ -1,9 +1,14 @@
-#ifndef THERMALCOMPONENT_H_
+#ifndef FSFW_THERMAL_THERMALCOMPONENT_H_
-#define THERMALCOMPONENT_H_
+#define FSFW_THERMAL_THERMALCOMPONENT_H_
 
-#include "CoreComponent.h"
+#include "ThermalComponentCore.h"
 
-class ThermalComponent: public CoreComponent {
+/**
+ * @brief
+ * @details
+ * Some more documentation.
+ */
+class ThermalComponent: public ThermalComponentCore {
 public:
 	struct Parameters {
 		float lowerNopLimit;
@@ -14,13 +19,35 @@ public:
 		float hysteresis;
 		float heaterSwitchoff;
 	};
+
+	/**
+	 * Non-Operational Temperatures
+	 */
 	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,
+	 * How to use.
+	 * @param reportingObjectId
+	 * @param domainId
+	 * @param temperaturePoolId
+	 * @param targetStatePoolId
+	 * @param currentStatePoolId
+	 * @param requestPoolId
+	 * @param dataSet
+	 * @param sensor
+	 * @param firstRedundantSensor
+	 * @param secondRedundantSensor
+	 * @param thermalModule
+	 * @param parameters
+	 * @param priority
+	 */
+	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,
@@ -29,7 +56,7 @@ public:
 
 	ReturnValue_t setTargetState(int8_t newState);
 
-	virtual ReturnValue_t setLimits( const uint8_t* data, uint32_t size);
+	virtual ReturnValue_t setLimits( const uint8_t* data, size_t size);
 
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,
@@ -39,15 +66,15 @@ protected:
 
 	NopParameters nopParameters;
 
-	State getState(float temperature, CoreComponent::Parameters parameters,
+	State getState(float temperature, ThermalComponentCore::Parameters parameters,
 			int8_t targetState);
 
 	virtual void checkLimits(State state);
 
 	virtual HeaterRequest getHeaterRequest(int8_t targetState, float temperature,
-			CoreComponent::Parameters parameters);
+			ThermalComponentCore::Parameters parameters);
 
 	State getIgnoredState(int8_t state);
 };
 
-#endif /* THERMALCOMPONENT_H_ */
+#endif /* FSFW_THERMAL_THERMALCOMPONENT_H_ */

thermal/ThermalComponentCore.cpp

@@ -0,0 +1,285 @@
+#include "ThermalComponentCore.h"
+
+ThermalComponentCore::ThermalComponentCore(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,
+		Parameters parameters, StateRequest initialTargetState) :
+		temperature(temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ),
+		currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		heaterRequest(requestPoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		parameters(parameters), domainId(domainId),
+		temperatureMonitor(reportingObjectId, domainId + 1,temperaturePoolId,
+				COMPONENT_TEMP_CONFIRMATION) {
+	//Set thermal state once, then leave to operator.
+	targetState.setReadWriteMode(PoolVariableIF::VAR_WRITE);
+	ReturnValue_t result = targetState.read();
+	if(result == HasReturnvaluesIF::RETURN_OK) {
+		targetState = initialTargetState;
+		targetState.setValid(true);
+		targetState.commit();
+	}
+	targetState.setReadWriteMode(PoolVariableIF::VAR_READ);
+}
+
+void ThermalComponentCore::addSensor(AbstractTemperatureSensor* sensor) {
+    this->sensor = sensor;
+}
+
+void ThermalComponentCore::addFirstRedundantSensor(
+        AbstractTemperatureSensor *firstRedundantSensor) {
+    this->firstRedundantSensor = firstRedundantSensor;
+}
+
+void ThermalComponentCore::addSecondRedundantSensor(
+        AbstractTemperatureSensor *secondRedundantSensor) {
+    this->secondRedundantSensor = secondRedundantSensor;
+}
+
+void ThermalComponentCore::addThermalModule(ThermalModule *thermalModule,
+        Priority priority) {
+    this->thermalModule = thermalModule;
+    if(thermalModule != nullptr) {
+        thermalModule->registerComponent(this, priority);
+    }
+}
+
+void ThermalComponentCore::setPriority(Priority priority) {
+    if(priority == SAFE) {
+        this->isSafeComponent = true;
+    }
+}
+
+ThermalComponentCore::~ThermalComponentCore() {
+}
+
+ThermalComponentIF::HeaterRequest ThermalComponentCore::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.value, getParameters(),
+				targetState.value);
+		currentState = state;
+		checkLimits(state);
+		request = getHeaterRequest(targetState.value, temperature.value,
+				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 ThermalComponentCore::markStateIgnored() {
+	currentState = getIgnoredState(currentState.value);
+}
+
+object_id_t ThermalComponentCore::getObjectId() {
+	return temperatureMonitor.getReporterId();
+	return 0;
+}
+
+float ThermalComponentCore::getLowerOpLimit() {
+	return parameters.lowerOpLimit;
+}
+
+
+
+ReturnValue_t ThermalComponentCore::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_HEATING:
+	case STATE_REQUEST_IGNORE:
+	case STATE_REQUEST_OPERATIONAL:
+		targetState = newState;
+		break;
+	case STATE_REQUEST_NON_OPERATIONAL:
+	default:
+		return INVALID_TARGET_STATE;
+	}
+	targetState.setValid(true);
+	targetState.commit();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ThermalComponentCore::setOutputInvalid() {
+	temperature = INVALID_TEMPERATURE;
+	temperature.setValid(PoolVariableIF::INVALID);
+	currentState.setValid(PoolVariableIF::INVALID);
+	heaterRequest = HEATER_DONT_CARE;
+	heaterRequest.setValid(PoolVariableIF::INVALID);
+	temperatureMonitor.setToUnchecked();
+}
+
+float ThermalComponentCore::getTemperature() {
+	if ((sensor != nullptr) && (sensor->isValid())) {
+		return sensor->getTemperature();
+	}
+
+	if ((firstRedundantSensor != nullptr) &&
+	        (firstRedundantSensor->isValid())) {
+		return firstRedundantSensor->getTemperature();
+	}
+
+	if ((secondRedundantSensor != nullptr) &&
+	        (secondRedundantSensor->isValid())) {
+		return secondRedundantSensor->getTemperature();
+	}
+
+	if (thermalModule != nullptr) {
+		float temperature = thermalModule->getTemperature();
+		if (temperature != ThermalModuleIF::INVALID_TEMPERATURE) {
+			return temperature;
+		} else {
+			return INVALID_TEMPERATURE;
+		}
+	} else {
+		return INVALID_TEMPERATURE;
+	}
+}
+
+ThermalComponentIF::State ThermalComponentCore::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 ThermalComponentCore::checkLimits(ThermalComponentIF::State state) {
+	//Checks operational limits only.
+	temperatureMonitor.translateState(state, temperature.value,
+			getParameters().lowerOpLimit, getParameters().upperOpLimit);
+
+}
+
+ThermalComponentIF::HeaterRequest ThermalComponentCore::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 ThermalComponentCore::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 ThermalComponentCore::updateMinMaxTemp() {
+	if (temperature == INVALID_TEMPERATURE) {
+		return;
+	}
+	if (temperature < minTemp) {
+		minTemp = static_cast<float>(temperature);
+	}
+	if (temperature > maxTemp) {
+		maxTemp = static_cast<float>(temperature);
+	}
+}
+
+uint8_t ThermalComponentCore::getDomainId() const {
+	return domainId;
+}
+
+ThermalComponentCore::Parameters ThermalComponentCore::getParameters() {
+	return parameters;
+}
+
+ReturnValue_t ThermalComponentCore::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_IDENTIFIER_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}

thermal/ThermalComponentCore.h

@@ -0,0 +1,117 @@
+#ifndef FSFW_THERMAL_THERMALCOMPONENTCORE_H_
+#define FSFW_THERMAL_THERMALCOMPONENTCORE_H_
+
+#include "ThermalMonitorReporter.h"
+#include "ThermalComponentIF.h"
+#include "AbstractTemperatureSensor.h"
+#include "ThermalModule.h"
+
+#include "../datapoollocal/LocalPoolVariable.h"
+
+/**
+ * @brief
+ * @details
+ */
+class ThermalComponentCore: public ThermalComponentIF {
+public:
+	struct Parameters {
+		float lowerOpLimit;
+		float upperOpLimit;
+		float heaterOn;
+		float hysteresis;
+		float heaterSwitchoff;
+	};
+
+	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
+
+	/**
+	 * Some documentation
+	 * @param reportingObjectId
+	 * @param domainId
+	 * @param temperaturePoolId
+	 * @param targetStatePoolId
+	 * @param currentStatePoolId
+	 * @param requestPoolId
+	 * @param dataSet
+	 * @param parameters
+	 * @param initialTargetState
+	 */
+	ThermalComponentCore(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, Parameters parameters,
+			StateRequest initialTargetState =
+					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
+
+	void addSensor(AbstractTemperatureSensor* firstRedundantSensor);
+	void addFirstRedundantSensor(
+	        AbstractTemperatureSensor* firstRedundantSensor);
+    void addSecondRedundantSensor(
+            AbstractTemperatureSensor* secondRedundantSensor);
+    void addThermalModule(ThermalModule* thermalModule, Priority priority);
+
+    void setPriority(Priority priority);
+
+	virtual ~ThermalComponentCore();
+
+	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 = nullptr;
+	AbstractTemperatureSensor *firstRedundantSensor = nullptr;
+	AbstractTemperatureSensor *secondRedundantSensor = nullptr;
+	ThermalModuleIF *thermalModule = nullptr;
+
+	lp_var_t<float> temperature;
+	lp_var_t<int8_t> targetState;
+	lp_var_t<int8_t> currentState;
+	lp_var_t<uint8_t> heaterRequest;
+
+	bool isHeating = false;
+
+	bool isSafeComponent = false;
+
+	float minTemp = 999;
+
+	float maxTemp = AbstractTemperatureSensor::ZERO_KELVIN_C;
+
+	Parameters parameters;
+
+	const uint8_t domainId;
+
+	ThermalMonitorReporter temperatureMonitor;
+
+	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 /* FSFW_THERMAL_THERMALCOMPONENT_CORE_H_ */

thermal/ThermalComponentIF.h

@@ -49,18 +49,18 @@ public:
 		SAFE = 0,             //!< SAFE
 		IDLE,                 //!< IDLE
 		PAYLOAD,              //!< PAYLOAD
-		NUMBER_OF_PRIORITIES          //!< MAX_PRIORITY
+		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_OFF = 0,   //!< REQUEST_EMERGENCY_OFF
-		HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
+		HEATER_REQUEST_EMERGENCY_ON,        //!< REQUEST_EMERGENCY_ON
-		HEATER_REQUEST_OFF,          //!< REQUEST_OFF
+		HEATER_REQUEST_OFF,                 //!< REQUEST_OFF
-		HEATER_REQUEST_ON,           //!< REQUEST_ON
+		HEATER_REQUEST_ON,                  //!< REQUEST_ON
-		HEATER_DONT_CARE             //!< DONT_CARE
+		HEATER_DONT_CARE                    //!< DONT_CARE
 	};
 
 	virtual ~ThermalComponentIF() {

thermal/ThermalModule.cpp

@@ -1,28 +1,31 @@
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringMessageContent.h"
 #include "ThermalModule.h"
-
 #include "AbstractTemperatureSensor.h"
 
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
+#include "../monitoring/LimitViolationReporter.h"
-		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
+#include "../monitoring/MonitoringMessageContent.h"
-		DataSet *dataSet, Parameters parameters,
+
+
+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(
+		oldStrategy(ACTIVE_SINGLE), parameters(parameters),
-				false), parameters(parameters), moduleTemperature(
+		moduleTemperature(moduleTemperaturePoolId, dataSet,
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
+				PoolVariableIF::VAR_WRITE),
-				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
+		currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
-				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
+		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
 	heater = new RedundantHeater(heaterParameters);
 }
 
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, DataSet* dataSet) :
+ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
+		LocalPoolDataSetBase* dataSet) :
-				false), parameters( { 0, 0 }), moduleTemperature(
+		oldStrategy(ACTIVE_SINGLE), parameters( { 0, 0 }),
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
+		moduleTemperature(moduleTemperaturePoolId, dataSet,
-				NULL), currentState(PoolVariableIF::INVALID, dataSet,
+				PoolVariableIF::VAR_WRITE),
-				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
+		currentState(gp_id_t(), dataSet,
-				dataSet, PoolVariableIF::VAR_READ) {
+				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
+				or (componentHeaterRequest
-						== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
+				== 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(
+ThermalComponentIF::HeaterRequest
-		bool safeOnly) {
+ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly) {
-	ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
+	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) {
-	DataSet mySet;
+//	GlobDataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
+//	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_WRITE);
+//			&mySet, PoolVariableIF::VAR_WRITE);
-	if (on) {
+//	if (on) {
-		writableTargetState = STATE_REQUEST_HEATING;
+//		writableTargetState = STATE_REQUEST_HEATING;
-	} else {
+//	} else {
-		writableTargetState = STATE_REQUEST_PASSIVE;
+//		writableTargetState = STATE_REQUEST_PASSIVE;
-	}
+//	}
-	mySet.commit(PoolVariableIF::VALID);
+//	mySet.commit(PoolVariableIF::VALID);
 }
 
 void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,

thermal/ThermalModule.h

@@ -1,16 +1,25 @@
-#ifndef THERMALMODULE_H_
+#ifndef FSFW_THERMAL_THERMALMODULE_H_
-#define THERMALMODULE_H_
+#define FSFW_THERMAL_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"
+
+//#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;
 
+/**
+ * @brief Allows creation of different thermal control domains within a system.
+ */
 class ThermalModule: public ThermalModuleIF {
 	friend class ThermalController;
 public:
@@ -19,11 +28,12 @@ public:
 		float hysteresis;
 	};
 
-	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
+	ThermalModule(gp_id_t moduleTemperaturePoolId, gp_id_t currentStatePoolId,
-			uint32_t targetStatePoolId, DataSet *dataSet, Parameters parameters,
+			gp_id_t targetStatePoolId, LocalPoolDataSetBase *dataSet,
-			RedundantHeater::Parameters heaterParameters);
+			Parameters parameters, RedundantHeater::Parameters heaterParameters);
 
-	ThermalModule(uint32_t moduleTemperaturePoolId, DataSet *dataSet);
+	ThermalModule(gp_id_t moduleTemperaturePoolId,
+			LocalPoolDataSetBase *dataSet);
 
 	virtual ~ThermalModule();
 
@@ -59,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;
 
-	db_float_t moduleTemperature;
+	lp_var_t<float> moduleTemperature;
+	//gp_float_t moduleTemperature;
 
-	RedundantHeater *heater;
+	RedundantHeater *heater = nullptr;
 
-	db_int8_t currentState;
+	lp_var_t<int8_t> currentState;
-	db_int8_t targetState;
+	lp_var_t<int8_t> targetState;
 
 	std::list<AbstractTemperatureSensor *> sensors;
 	std::list<ComponentData> components;
@@ -89,4 +100,4 @@ protected:
 	void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
 };
 
-#endif /* THERMALMODULE_H_ */
+#endif /* FSFW_THERMAL_THERMALMODULE_H_ */

thermal/ThermalMonitorReporter.cpp

@@ -0,0 +1,75 @@
+#include "ThermalMonitorReporter.h"
+#include "ThermalComponentIF.h"
+
+#include "../monitoring/MonitoringIF.h"
+
+ThermalMonitorReporter::~ThermalMonitorReporter() {
+}
+
+void ThermalMonitorReporter::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 ThermalMonitorReporter::isAboveHighLimit() {
+	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+ReturnValue_t ThermalMonitorReporter::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;
+	}
+}

thermal/ThermalMonitorReporter.h

@@ -0,0 +1,28 @@
+#ifndef FSFW_THERMAL_THERMALMONITORREPORTER_H_
+#define FSFW_THERMAL_THERMALMONITORREPORTER_H_
+
+#include "ThermalComponentIF.h"
+#include "../monitoring/MonitorReporter.h"
+
+
+/**
+ * @brief   Monitor Reporter implementation for thermal components.
+ */
+class ThermalMonitorReporter: public MonitorReporter<float> {
+public:
+	template<typename ... Args>
+	ThermalMonitorReporter(Args ... args) :
+			MonitorReporter<float>(std::forward<Args>(args)...) {
+	}
+	~ThermalMonitorReporter();
+	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 /* FSFW_THERMAL_THERMALMONITORREPORTERREPORTER_H_ */

thermal/tcsDefinitions.h

@@ -2,7 +2,7 @@
 #define TCSDEFINITIONS_H_
 
 
-static const uint32_t INVALID_TEMPERATURE = 999;
+static const float INVALID_TEMPERATURE = 999;
 
 
 #endif /* TCSDEFINITIONS_H_ */