Today's the day. Renamed platform to framework.

fdir/ConfirmsFailuresIF.h

@@ -0,0 +1,26 @@
+/*
+ * ConfirmsFailuresIF.h
+ *
+ *  Created on: 10.09.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
+#define FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
+
+#include <framework/ipc/MessageQueue.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+class ConfirmsFailuresIF {
+public:
+	static const uint8_t INTERFACE_ID = HANDLES_FAILURES_IF;
+	static const ReturnValue_t YOUR_FAULT = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t MY_FAULT = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t CONFIRM_LATER = MAKE_RETURN_CODE(2);
+	virtual ~ConfirmsFailuresIF() {}
+	virtual MessageQueueId_t getEventReceptionQueue() = 0;
+};
+
+
+
+#endif /* FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_ */

fdir/EventCorrelation.cpp

@@ -0,0 +1,51 @@
+/*
+ * EventCorrelation.cpp
+ *
+ *  Created on: 15.10.2015
+ *      Author: baetz
+ */
+
+#include <framework/fdir/EventCorrelation.h>
+
+EventCorrelation::EventCorrelation(uint32_t timeout) :
+		eventPending(false) {
+	correlationTimer.setTimeout(timeout);
+}
+
+EventCorrelation::~EventCorrelation() {
+}
+
+EventCorrelation::State EventCorrelation::doesEventCorrelate() {
+	if (correlationTimer.isBusy()) {
+		eventPending = false;
+		return CORRELATED;
+	} else {
+		if (eventPending) {
+			return ALREADY_STARTED;
+		} else {
+			eventPending = true;
+			correlationTimer.resetTimer();
+			return CORRELATION_STARTED;
+		}
+	}
+}
+
+bool EventCorrelation::isEventPending() {
+	if (eventPending) {
+		eventPending = false;
+		return true;
+	} else {
+		correlationTimer.resetTimer();
+		return false;
+	}
+}
+
+bool EventCorrelation::hasPendingEventTimedOut() {
+	if (correlationTimer.hasTimedOut()) {
+		bool temp = eventPending;
+		eventPending = false;
+		return temp;
+	} else {
+		return false;
+	}
+}

fdir/EventCorrelation.h

@@ -0,0 +1,30 @@
+/*
+ * EventCorrelation.h
+ *
+ *  Created on: 15.10.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_FDIR_EVENTCORRELATION_H_
+#define FRAMEWORK_FDIR_EVENTCORRELATION_H_
+
+#include <framework/timemanager/Countdown.h>
+
+class EventCorrelation {
+public:
+	enum State {
+		CORRELATION_STARTED,
+		CORRELATED,
+		ALREADY_STARTED
+	};
+	EventCorrelation(uint32_t timeout);
+	~EventCorrelation();
+	EventCorrelation::State doesEventCorrelate();
+	bool isEventPending();
+	bool hasPendingEventTimedOut();
+	Countdown correlationTimer;
+private:
+	bool eventPending;
+};
+
+#endif /* FRAMEWORK_FDIR_EVENTCORRELATION_H_ */

fdir/FDIRBase.cpp

@@ -0,0 +1,156 @@
+/*
+ * FDIRBase.cpp
+ *
+ *  Created on: 09.09.2015
+ *      Author: baetz
+ */
+
+#include <framework/events/EventManagerIF.h>
+#include <framework/fdir/FDIRBase.h>
+#include <framework/health/HasHealthIF.h>
+#include <framework/health/HealthMessage.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
+FDIRBase::FDIRBase(object_id_t owner, object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) :
+		eventQueue(messageDepth, EventMessage::EVENT_MESSAGE_SIZE), ownerId(
+				owner), owner(NULL), faultTreeParent(parent), parameterDomainBase(parameterDomainBase) {
+}
+
+FDIRBase::~FDIRBase() {
+}
+
+ReturnValue_t FDIRBase::initialize() {
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+			objects::EVENT_MANAGER);
+	if (manager == NULL) {
+		return RETURN_FAILED;
+	}
+	ReturnValue_t result = manager->registerListener(eventQueue.getId());
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (ownerId != 0) {
+		result = manager->subscribeToAllEventsFrom(eventQueue.getId(), ownerId);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		owner = objectManager->get<HasHealthIF>(ownerId);
+		if (owner == NULL) {
+			return RETURN_FAILED;
+		}
+	}
+	if (faultTreeParent != 0) {
+		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
+				faultTreeParent);
+		if (parentIF == NULL) {
+			return RETURN_FAILED;
+		}
+		eventQueue.setDefaultDestination(parentIF->getEventReceptionQueue());
+	}
+	return RETURN_OK;
+}
+
+void FDIRBase::checkForFailures() {
+	EventMessage event;
+	for (ReturnValue_t result = eventQueue.receiveMessage(&event);
+			result == RETURN_OK; result = eventQueue.receiveMessage(&event)) {
+		if (event.getSender() == eventQueue.getId()) {
+			//We already got this event, because we sent it.
+			continue;
+		}
+		switch (event.getMessageId()) {
+		case EventMessage::EVENT_MESSAGE:
+			if (isFdirDisabledForSeverity(event.getSeverity())) {
+				//We do not handle events when disabled.
+				continue;
+			}
+			eventReceived(&event);
+			break;
+		case EventMessage::CONFIRMATION_REQUEST:
+			doConfirmFault(&event);
+			break;
+		case EventMessage::YOUR_FAULT:
+			eventConfirmed(&event);
+			break;
+		case EventMessage::MY_FAULT:
+			wasParentsFault(&event);
+			break;
+		default:
+			break;
+		}
+	}
+	decrementFaultCounters();
+}
+
+void FDIRBase::setOwnerHealth(HasHealthIF::HealthState health) {
+	if (owner != NULL) {
+		owner->setHealth(health);
+	}
+	//else: owner has no health.
+
+}
+
+MessageQueueId_t FDIRBase::getEventReceptionQueue() {
+	return eventQueue.getId();
+}
+
+ReturnValue_t FDIRBase::sendConfirmationRequest(EventMessage* event,
+		MessageQueueId_t destination) {
+	event->setMessageId(EventMessage::CONFIRMATION_REQUEST);
+	if (destination != 0) {
+		return eventQueue.sendMessage(destination, event);
+	} else if (faultTreeParent != 0) {
+		return eventQueue.sendToDefault(event);
+	}
+	return RETURN_FAILED;
+}
+
+void FDIRBase::eventConfirmed(EventMessage* event) {
+}
+
+void FDIRBase::wasParentsFault(EventMessage* event) {
+}
+
+void FDIRBase::doConfirmFault(EventMessage* event) {
+	ReturnValue_t result = confirmFault(event);
+	if (result == YOUR_FAULT) {
+		event->setMessageId(EventMessage::YOUR_FAULT);
+		eventQueue.reply(event);
+	} else if (result == MY_FAULT) {
+		event->setMessageId(EventMessage::MY_FAULT);
+		eventQueue.reply(event);
+	} else {
+
+	}
+}
+
+ReturnValue_t FDIRBase::confirmFault(EventMessage* event) {
+	return YOUR_FAULT;
+}
+
+void FDIRBase::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	//With this mechanism, all events are disabled for a certain device.
+	//That's not so good for visibility.
+	if (isFdirDisabledForSeverity(EVENT::getSeverity(event))) {
+		return;
+	}
+	EventMessage message(event, ownerId, parameter1, parameter2);
+	EventManagerIF::triggerEvent(&message, eventQueue.getId());
+	eventReceived(&message);
+}
+
+bool FDIRBase::isFdirDisabledForSeverity(EventSeverity_t severity) {
+	if ((owner != NULL) && (severity != SEVERITY::INFO)) {
+		if (owner->getHealth() == HasHealthIF::EXTERNAL_CONTROL) {
+			//External control disables handling of fault messages.
+			return true;
+		}
+	}
+	return false;
+}
+
+void FDIRBase::throwFdirEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	EventMessage message(event, ownerId, parameter1, parameter2);
+	EventManagerIF::triggerEvent(&message, eventQueue.getId());
+}

fdir/FDIRBase.h

@@ -0,0 +1,49 @@
+/*
+ * FDIRBase.h
+ *
+ *  Created on: 09.09.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_FDIR_FDIRBASE_H_
+#define FRAMEWORK_FDIR_FDIRBASE_H_
+
+#include <framework/events/EventMessage.h>
+#include <framework/fdir/ConfirmsFailuresIF.h>
+#include <framework/fdir/FaultCounter.h>
+#include <framework/health/HealthMessage.h>
+#include <framework/ipc/MessageQueue.h>
+#include <framework/parameters/HasParametersIF.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+class FDIRBase: public HasReturnvaluesIF, public ConfirmsFailuresIF, public HasParametersIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
+	static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::INFO); //!< FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
+	static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, SEVERITY::MEDIUM); //!< FDIR tries to restart device. Par1: event that caused recovery.
+	static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, SEVERITY::MEDIUM); //!< FDIR turns off device. Par1: event that caused recovery.
+	FDIRBase(object_id_t owner, object_id_t parent = 0, uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);
+	virtual ~FDIRBase();
+	virtual ReturnValue_t initialize();
+	void checkForFailures();
+	MessageQueueId_t getEventReceptionQueue();
+	virtual void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+protected:
+	MessageQueue eventQueue;
+	object_id_t ownerId;
+	HasHealthIF* owner;
+	object_id_t faultTreeParent;
+	uint8_t parameterDomainBase;
+	void setOwnerHealth(HasHealthIF::HealthState health);
+	virtual ReturnValue_t eventReceived(EventMessage* event) = 0;
+	virtual void eventConfirmed(EventMessage* event);
+	virtual void wasParentsFault(EventMessage* event);
+	virtual ReturnValue_t confirmFault(EventMessage* event);
+	virtual void decrementFaultCounters() = 0;
+	ReturnValue_t sendConfirmationRequest(EventMessage* event, MessageQueueId_t destination = 0);
+	void throwFdirEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+private:
+	void doConfirmFault(EventMessage* event);
+	bool isFdirDisabledForSeverity(EventSeverity_t severity);
+};
+
+#endif /* FRAMEWORK_FDIR_FDIRBASE_H_ */

fdir/FaultCounter.cpp

@@ -0,0 +1,93 @@
+/*
+ * FaultCounter.cpp
+ *
+ *  Created on: 15.09.2015
+ *      Author: baetz
+ */
+
+#include <framework/fdir/FaultCounter.h>
+
+FaultCounter::FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
+		uint8_t setParameterDomain) :
+		parameterDomain(setParameterDomain), timer(), faultCount(0), failureThreshold(
+				failureThreshold) {
+	timer.setTimeout(decrementAfterMs);
+}
+
+FaultCounter::~FaultCounter() {
+}
+
+void FaultCounter::increment(uint32_t amount) {
+	if (faultCount == 0) {
+		timer.resetTimer();
+	}
+	faultCount += amount;
+}
+
+bool FaultCounter::checkForDecrement() {
+	if (timer.hasTimedOut()) {
+		timer.resetTimer();
+		if (faultCount > 0) {
+			faultCount--;
+			return true;
+		}
+	}
+	return false;
+}
+
+bool FaultCounter::incrementAndCheck(uint32_t amount) {
+	increment(amount);
+	return aboveThreshold();
+}
+
+bool FaultCounter::aboveThreshold() {
+	if (faultCount > failureThreshold) {
+		faultCount = 0;
+		return true;
+	} else {
+		return false;
+	}
+}
+
+void FaultCounter::clear() {
+	faultCount = 0;
+}
+
+void FaultCounter::setFailureThreshold(uint32_t failureThreshold) {
+	this->failureThreshold = failureThreshold;
+}
+
+void FaultCounter::setFaultDecrementTimeMs(uint32_t timeMs) {
+	timer.setTimeout(timeMs);
+}
+
+FaultCounter::FaultCounter() :
+		parameterDomain(0), timer(), faultCount(0), failureThreshold(0) {
+}
+
+ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	if (domainId != parameterDomain) {
+		return INVALID_DOMAIN_ID;
+	}
+
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set(failureThreshold);
+		break;
+	case 1:
+		parameterWrapper->set(faultCount);
+		break;
+	case 2:
+		parameterWrapper->set(timer.timeout);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FaultCounter::setParameterDomain(uint8_t domain) {
+	parameterDomain = domain;
+}

fdir/FaultCounter.h

@@ -0,0 +1,45 @@
+/*
+ * FaultCounter.h
+ *
+ *  Created on: 15.09.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_FDIR_FAULTCOUNTER_H_
+#define FRAMEWORK_FDIR_FAULTCOUNTER_H_
+
+#include <framework/parameters/HasParametersIF.h>
+#include <framework/timemanager/Countdown.h>
+
+class FaultCounter: public HasParametersIF {
+public:
+	FaultCounter();
+	FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
+			uint8_t setParameterDomain = 0);
+	virtual ~FaultCounter();
+
+	bool incrementAndCheck(uint32_t amount = 1);
+
+	void increment(uint32_t amount = 1);
+
+	bool checkForDecrement();
+
+	bool aboveThreshold();
+
+	void clear();
+	void setFailureThreshold(uint32_t failureThreshold);
+	void setFaultDecrementTimeMs(uint32_t timeMs);
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+	void setParameterDomain(uint8_t domain);
+private:
+	uint8_t parameterDomain;
+	Countdown timer;
+	uint32_t faultCount;
+	uint32_t failureThreshold;
+};
+
+#endif /* FRAMEWORK_FDIR_FAULTCOUNTER_H_ */