Merge remote-tracking branch 'upstream/development' into mueller/master

defaultcfg/fsfwconfig/FSFWConfig.h

@@ -42,6 +42,13 @@
 //! Specify whether a special mode store is used for Subsystem components.
 #define FSFW_USE_MODESTORE          0
 
+//! Defines if the real time scheduler for linux should be used.
+//! If set to 0, this will also disable priority settings for linux
+//! as most systems will not allow to set nice values without privileges
+//! For embedded linux system set this to 1.
+//! If set to 1 the binary needs "cap_sys_nice=eip" privileges to run
+#define FSFW_USE_REALTIME_FOR_LINUX 1
+
 namespace fsfwconfig {
 //! Default timestamp size. The default timestamp will be an eight byte CDC
 //! short timestamp.
@@ -60,12 +67,6 @@ static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
 
 static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
 
-//! Defines if the real time scheduler for linux should be used.
-//! If set to 0, this will also disable priority settings for linux
-//! as most systems will not allow to set nice values without privileges
-//! For embedded linux system set this to 1.
-//! If set to 1 the binary needs "cap_sys_nice=eip" privileges to run
-#define FSFW_USE_REALTIME_FOR_LINUX 1
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

devicehandlers/AssemblyBase.h

@@ -24,6 +24,13 @@
  * 1. check logic when active-> checkChildrenStateOn
  * 2. transition logic to change the mode -> commandChildren
  *
+ * Important:
+ *
+ * The implementation must call registerChild(object_id_t child)
+ * for all commanded children during initialization.
+ * The implementation must call the initialization function of the base class.
+ * (This will call the function in SubsystemBase)
+ *
  */
 class AssemblyBase: public SubsystemBase {
 public:
@@ -41,9 +48,6 @@ public:
 	virtual ~AssemblyBase();
 
 protected:
-
-    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
-    // (or return internalState directly?)
     /**
      * Command children to reach [mode,submode] combination
      * Can be done by setting #commandsOutstanding correctly,
@@ -68,6 +72,18 @@ protected:
     virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
             Submode_t wantedSubmode) = 0;
 
+    /**
+     * Check whether a combination of mode and submode is valid.
+     *
+     * Ground Controller like precise return values from HasModesIF.
+     * So, please return any of them.
+     *
+     * @param mode The targeted mode
+     * @param submode The targeted submmode
+     * @return Any information why this combination is invalid from HasModesIF
+     * 			like HasModesIF::INVALID_SUBMODE.
+     * 			On success return HasReturnvaluesIF::RETURN_OK
+     */
     virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
             Submode_t submode) = 0;
 

osal/linux/PosixThread.cpp

@@ -223,8 +223,16 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	status = pthread_create(&thread,&attributes,fnc_,arg_);
 	if(status != 0){
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "Posix Thread create failed with: " <<
+		sif::error << "PosixThread::createTask: Failed with: " <<
 				strerror(status) << std::endl;
+		sif::error << "For FSFW_USE_REALTIME_FOR_LINUX == 1 make sure to call " <<
+		        "\"all sudo setcap 'cap_sys_nice=eip'\" on the application or set "
+		        "/etc/security/limit.conf" << std::endl;
+#else
+		sif::printError("PosixThread::createTask: Create failed with: %s\n", strerror(status));
+		sif::printError("For FSFW_USE_REALTIME_FOR_LINUX == 1 make sure to call "
+		        "\"all sudo setcap 'cap_sys_nice=eip'\" on the application or set "
+                "/etc/security/limit.conf\n");
 #endif
 	}
 

subsystem/SubsystemBase.cpp

@@ -5,8 +5,7 @@
 
 SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
 		Mode_t initialMode, uint16_t commandQueueDepth) :
-		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
+		SystemObject(setObjectId), mode(initialMode),
-		childrenChangedMode(false),
 		commandQueue(QueueFactory::instance()->createMessageQueue(
 		        commandQueueDepth, CommandMessage::MAX_MESSAGE_SIZE)),
 		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
@@ -167,16 +166,16 @@ MessageQueueId_t SubsystemBase::getCommandQueue() const {
 }
 
 ReturnValue_t SubsystemBase::initialize() {
-	MessageQueueId_t parentQueue = 0;
+	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
 	ReturnValue_t result = SystemObject::initialize();
 
 	if (result != RETURN_OK) {
 		return result;
 	}
 
-	if (parentId != 0) {
+	if (parentId != objects::NO_OBJECT) {
 		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
+		if (parent == nullptr) {
 			return RETURN_FAILED;
 		}
 		parentQueue = parent->getCommandQueue();

subsystem/SubsystemBase.h

@@ -37,6 +37,17 @@ public:
 
 	virtual MessageQueueId_t getCommandQueue() const override;
 
+	/**
+	 * Function to register the child objects.
+	 * Performs a checks if the child does implement HasHealthIF and/or HasModesIF
+	 *
+	 * 	Also adds them to the internal childrenMap.
+	 *
+	 * @param objectId
+	 * @return RETURN_OK if successful
+	 * 		   CHILD_DOESNT_HAVE_MODES if Child is no HasHealthIF and no HasModesIF
+	 * 		   COULD_NOT_INSERT_CHILD If the Child could not be added to the ChildrenMap
+	 */
 	ReturnValue_t registerChild(object_id_t objectId);
 
 	virtual ReturnValue_t initialize() override;
@@ -56,9 +67,9 @@ protected:
 
 	Mode_t mode;
 
-	Submode_t submode;
+	Submode_t submode = SUBMODE_NONE;
 
-	bool childrenChangedMode;
+	bool childrenChangedMode = false;
 
 	/**
 	 * Always check this against <=0, so you are robust against too many replies

thermal/Heater.cpp

@@ -1,15 +1,13 @@
-#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
 #include "Heater.h"
 
+#include "../devicehandlers/DeviceHandlerFailureIsolation.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(
+HealthDevice(objectId, 0), internalState(STATE_OFF), switch0(switch0), switch1(switch1),
-				NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(
+        heaterOnCountdown(10800000)/*about two orbits*/,
-				false), timedOut(false), reactedToBeingFaulty(false), passive(
+		parameterHelper(this) {
-				false), eventQueue(NULL), heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(
-				this), lastAction(CLEAR) {
     eventQueue = QueueFactory::instance()->createMessageQueue();
 }
 
@@ -226,7 +224,6 @@ void Heater::setSwitch(uint8_t number, ReturnValue_t state,
                         triggerEvent(HEATER_STAYED_ON);
                     }
                 }
-				//SHOULDDO MiniOps during switch timeout leads to a faulty switch
             }
         }
     }
@@ -319,7 +316,9 @@ void Heater::handleEventQueue() {
             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.
+            // HEATER_STAYED_ON is a setting if faulty does not help, but we need to reach a stable state and can check
+            // for being faulty before throwing this event again.
+            case HEATER_STAYED_ON:
                 if (healthHelper.healthTable->isCommandable(getObjectId())) {
                     healthHelper.setHealth(HasHealthIF::FAULTY);
                     internalState = STATE_FAULTY;

thermal/Heater.h

@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_THERMAL_HEATER_H_
+#ifndef FSFW_THERMAL_HEATER_H_
-#define FRAMEWORK_THERMAL_HEATER_H_
+#define FSFW_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>
+#include <cstdint>
-//class RedundantHeater;
+
 
 class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
     friend class RedundantHeater;
@@ -47,35 +47,38 @@ protected:
         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_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_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
+        // Entered when under external control and a fdir reaction would be triggered.
-							   //if no fdir reaction is triggered under external control the state is still ok and no need for any special treatment is needed
+        // This is useful when leaving external control into an unknown state
+        STATE_EXTERNAL_CONTROL
+        // 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;
+    PowerSwitchIF *powerSwitcher = nullptr;
-	MessageQueueId_t pcduQueueId;
+    MessageQueueId_t pcduQueueId = MessageQueueIF::NO_QUEUE;
 
     uint8_t switch0;
     uint8_t switch1;
 
-	bool wasOn;
+    bool wasOn = false;
 
-	bool timedOut;
+    bool timedOut = false;
 
-	bool reactedToBeingFaulty;
+    bool reactedToBeingFaulty = false;
 
-	bool passive;
+    bool passive = false;
 
-	MessageQueueIF* eventQueue;
+    MessageQueueIF* eventQueue = nullptr;
     Countdown heaterOnCountdown;
     Countdown switchCountdown;
     ParameterHelper parameterHelper;
 
     enum Action {
         SET, CLEAR
-	} lastAction;
+    } lastAction = CLEAR;
 
     void doAction(Action action);
 
@@ -87,4 +90,4 @@ protected:
     void handleEventQueue();
 };
 
-#endif /* FRAMEWORK_THERMAL_HEATER_H_ */
+#endif /* FSFW_THERMAL_HEATER_H_ */

thermal/TemperatureSensor.h

@@ -1,5 +1,5 @@
-#ifndef TEMPERATURESENSOR_H_
+#ifndef FSFW_THERMAL_TEMPERATURESENSOR_H_
-#define TEMPERATURESENSOR_H_
+#define FSFW_THERMAL_TEMPERATURESENSOR_H_
 
 #include "tcsDefinitions.h"
 #include "AbstractTemperatureSensor.h"
@@ -61,22 +61,21 @@ public:
 	/**
 	 * Instantiate Temperature Sensor Object.
 	 * @param setObjectid       objectId of the sensor object
-	 * @param inputValue    Pointer to input value which is converted to a temperature
+	 * @param inputTemperature  Pointer to a raw input value which is converted to an floating
-	 * @param variableGpid  Global Pool ID of the output value
+	 *                          point C output temperature
-	 * @param inputVariable Input variable handle
+	 * @param outputGpid        Global Pool ID of the output value
 	 * @param vectorIndex       Vector Index for the sensor monitor
 	 * @param parameters        Calculation parameters, temperature limits, gradient limit
 	 * @param outputSet         Output dataset for the output temperature to fetch it with read()
-	 * @param thermalModule respective thermal module, if it has one
+	 * @param thermalModule     Respective thermal module, if it has one
 	 */
-	TemperatureSensor(object_id_t setObjectid,
+	TemperatureSensor(object_id_t setObjectid,lp_var_t<limitType>* inputTemperature,
-			inputType *inputValue, gp_id_t variableGpid, PoolVariableIF* inputVariable,
+			gp_id_t outputGpid, uint8_t vectorIndex, Parameters parameters = {0, 0, 0, 0, 0, 0},
-			uint8_t vectorIndex, Parameters parameters = {0, 0, 0, 0, 0, 0},
+			LocalPoolDataSetBase *outputSet = nullptr, ThermalModuleIF *thermalModule = nullptr) :
-			LocalPoolDataSetBase *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
 			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
-			inputValue(inputValue), poolVariable(inputVariable),
+			inputTemperature(inputTemperature),
-			outputTemperature(variableGpid, outputSet, PoolVariableIF::VAR_WRITE),
+			outputTemperature(outputGpid, outputSet, PoolVariableIF::VAR_WRITE),
-			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR, poolVariable,
+			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR, outputGpid,
 				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
 				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
 			oldTemperature(20), uptimeOfOldTemperature({ thermal::INVALID_TEMPERATURE, 0 }) {
@@ -110,10 +109,7 @@ protected:
 
 	UsedParameters parameters;
 
-	inputType* inputValue;
+	lp_var_t<limitType>* inputTemperature;
-
-	PoolVariableIF* poolVariable;
-
 	lp_var_t<float> outputTemperature;
 
 	LimitMonitor<limitType> sensorMonitor;
@@ -122,22 +118,27 @@ protected:
 	timeval uptimeOfOldTemperature;
 
 	void doChildOperation() {
-		if ((not poolVariable->isValid()) or
+		ReturnValue_t result = inputTemperature->read(MutexIF::TimeoutType::WAITING, 20);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+
+		if ((not inputTemperature->isValid()) or
 		        (not healthHelper.healthTable->isHealthy(getObjectId()))) {
 			setInvalid();
 			return;
 		}
 
-		outputTemperature = calculateOutputTemperature(*inputValue);
+		outputTemperature = calculateOutputTemperature(inputTemperature->value);
 		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.
+			// In theory, we could use an AbsValueMonitor to monitor the gradient.
-			//But this would require storing the maxGradient 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.
+			// The concept of delta limits is a bit strange anyway.
 			float deltaTime;
 			float deltaTemp;
 
@@ -150,11 +151,11 @@ protected:
 			}
 			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
+				// 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(outputTemperature.value);
 
 		if (sensorMonitor.isOutOfLimits()) {
@@ -181,7 +182,10 @@ public:
 	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.)
+	//! 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 uint16_t DEFAULT_CONFIRMATION_COUNT = 1;
 
 	static const uint8_t DOMAIN_ID_SENSOR = 1;
 
@@ -221,4 +225,4 @@ public:
 
 };
 
-#endif /* TEMPERATURESENSOR_H_ */
+#endif /* FSFW_THERMAL_TEMPERATURESENSOR_H_ */