restructure repository

src/core/power/CMakeLists.txt

@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Fuse.cpp
+		PowerComponent.cpp
+		PowerSensor.cpp
+		PowerSwitcher.cpp
+)

src/core/power/Fuse.cpp

@@ -0,0 +1,264 @@
+#include "Fuse.h"
+
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../objectmanager/ObjectManager.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../ipc/QueueFactory.h"
+
+object_id_t Fuse::powerSwitchId = 0;
+
+Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId,
+		sid_t variableSet, VariableIds ids,
+		float maxCurrent, uint16_t confirmationCount) :
+		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId),
+		currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
+				maxCurrent, FUSE_CURRENT_HIGH),
+		powerMonitor(fuseObjectId, 2, ids.poolIdPower,
+				confirmationCount),
+		set(variableSet), voltage(ids.pidVoltage, &set),
+		current(ids.pidCurrent, &set), state(ids.pidState, &set),
+		power(ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE),
+		parameterHelper(this), healthHelper(this, fuseObjectId) {
+	commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Fuse::~Fuse() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+void Fuse::addDevice(PowerComponentIF* switchSet) {
+	devices.push_back(switchSet);
+}
+
+ReturnValue_t Fuse::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	powerIF = ObjectManager::instance()->get<PowerSwitchIF>(powerSwitchId);
+	if (powerIF == NULL) {
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void Fuse::calculatePowerLimits(float* low, float* high) {
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		if (areSwitchesOfComponentOn(iter)) {
+			*low += (*iter)->getMin();
+			*high += (*iter)->getMax();
+		}
+	}
+}
+
+ReturnValue_t Fuse::check() {
+	set.read();
+	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
+		setAllMonitorsToUnchecked();
+		set.setValidity(false, true);
+		return set.commit();
+	}
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	checkFuseState();
+	calculateFusePower();
+	//Check if power is valid and if fuse state is off or invalid.
+	if (!power.isValid() || (state == 0) || !state.isValid()) {
+		result = powerMonitor.setToInvalid();
+	} else {
+		float lowLimit = 0.0;
+		float highLimit = RESIDUAL_POWER;
+		calculatePowerLimits(&lowLimit, &highLimit);
+		result = powerMonitor.checkPower(power.value, lowLimit, highLimit);
+		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
+			reportEvents(POWER_BELOW_LOW_LIMIT);
+		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
+			reportEvents(POWER_ABOVE_HIGH_LIMIT);
+		}
+	}
+	set.commit();
+	return result;
+}
+
+ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = RETURN_FAILED;
+	for (DeviceList::const_iterator iter = devices.begin();
+			iter != devices.end(); iter++) {
+		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return RETURN_OK;
+}
+
+size_t Fuse::getSerializedSize() const {
+	uint32_t size = 0;
+	for (DeviceList::const_iterator iter = devices.begin();
+			iter != devices.end(); iter++) {
+		size += (*iter)->getSerializedSize();
+	}
+	return size;
+}
+
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
+        Endianness streamEndianness) {
+	ReturnValue_t result = RETURN_FAILED;
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		result = (*iter)->deSerialize(buffer, size, streamEndianness);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return RETURN_OK;
+}
+
+uint8_t Fuse::getFuseId() const {
+	return fuseId;
+}
+
+void Fuse::calculateFusePower() {
+	ReturnValue_t result1 = currentLimit.check();
+	if (result1 != HasReturnvaluesIF::RETURN_OK || !(voltage.isValid())) {
+		power.setValid(PoolVariableIF::INVALID);
+		return;
+	}
+	//Calculate fuse power.
+	power.value = current.value * voltage.value;
+	power.setValid(PoolVariableIF::VALID);
+}
+
+ReturnValue_t Fuse::performOperation(uint8_t opCode) {
+	checkCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Fuse::reportEvents(Event event) {
+	if (!powerMonitor.isEventEnabled()) {
+		return;
+	}
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		if (areSwitchesOfComponentOn(iter)) {
+			EventManagerIF::triggerEvent((*iter)->getDeviceObjectId(), event);
+		}
+	}
+}
+
+MessageQueueId_t Fuse::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void Fuse::setAllMonitorsToUnchecked() {
+	currentLimit.setToUnchecked();
+	powerMonitor.setToUnchecked();
+}
+
+void Fuse::checkCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = parameterHelper.handleParameterMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	command.setToUnknownCommand();
+	commandQueue->reply(&command);
+}
+
+void Fuse::checkFuseState() {
+	if (!state.isValid()) {
+		oldFuseState = 0;
+		return;
+	}
+	if (state == 0) {
+		if (oldFuseState != 0) {
+			reportEvents(FUSE_WENT_OFF);
+		}
+	}
+	oldFuseState = state.value;
+}
+
+float Fuse::getPower() {
+	if (power.isValid()) {
+		return power.value;
+	} else {
+		return 0.0;
+	}
+}
+
+void Fuse::setDataPoolEntriesInvalid() {
+	set.read();
+	set.setValidity(false, true);
+	set.commit();
+}
+
+ReturnValue_t Fuse::getParameter(uint8_t domainId, uint8_t uniqueId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	ReturnValue_t result = currentLimit.getParameter(domainId, uniqueId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = powerMonitor.getParameter(domainId, uniqueId, parameterWrapper,
+			newValues, startAtIndex);
+	return result;
+}
+
+bool Fuse::areSwitchesOfComponentOn(DeviceList::iterator iter) {
+	if (powerIF->getSwitchState((*iter)->getSwitchId1())
+			!= PowerSwitchIF::SWITCH_ON) {
+		return false;
+	}
+	if ((*iter)->hasTwoSwitches()) {
+		if ((powerIF->getSwitchState((*iter)->getSwitchId2())
+				!= PowerSwitchIF::SWITCH_ON)) {
+			return false;
+		}
+	}
+	return true;
+}
+
+bool Fuse::isPowerValid() {
+	return power.isValid();
+}
+
+ReturnValue_t Fuse::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return RETURN_OK;
+}
+
+HasHealthIF::HealthState Fuse::getHealth() {
+	return healthHelper.getHealth();
+}
+
+ReturnValue_t Fuse::PowerMonitor::checkPower(float sample, float lowerLimit,
+		float upperLimit) {
+	if (sample > upperLimit) {
+		return this->monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
+				upperLimit);
+	} else if (sample < lowerLimit) {
+		return this->monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
+				lowerLimit);
+	} else {
+		return this->monitorStateIs(RETURN_OK, sample, 0.0); //Within limits.
+	}
+}

src/core/power/PowerComponent.cpp

@@ -0,0 +1,82 @@
+#include "PowerComponent.h"
+#include "../serialize/SerializeAdapter.h"
+
+
+PowerComponent::PowerComponent(): switchId1(0xFF), switchId2(0xFF),
+        doIHaveTwoSwitches(false) {
+}
+
+PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min,
+        float max, uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
+		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2),
+		doIHaveTwoSwitches(twoSwitches), minPower(min), maxPower(max),
+		moduleId(moduleId) {
+}
+
+ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&minPower, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerializeAdapter::serialize(&maxPower, buffer, size, maxSize,
+			streamEndianness);
+}
+
+size_t PowerComponent::getSerializedSize() const {
+	return sizeof(minPower) + sizeof(maxPower);
+}
+
+object_id_t PowerComponent::getDeviceObjectId() {
+	return deviceObjectId;
+}
+
+uint8_t PowerComponent::getSwitchId1() {
+	return switchId1;
+}
+
+uint8_t PowerComponent::getSwitchId2() {
+	return switchId2;
+}
+
+bool PowerComponent::hasTwoSwitches() {
+	return doIHaveTwoSwitches;
+}
+
+float PowerComponent::getMin() {
+	return minPower;
+}
+
+float PowerComponent::getMax() {
+	return maxPower;
+}
+
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
+        Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&minPower, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerializeAdapter::deSerialize(&maxPower, buffer, size, streamEndianness);
+}
+
+ReturnValue_t PowerComponent::getParameter(uint8_t domainId, uint8_t uniqueId,
+        ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+        uint16_t startAtIndex) {
+	if (domainId != moduleId) {
+		return INVALID_DOMAIN_ID;
+	}
+	switch (uniqueId) {
+	case 0:
+		parameterWrapper->set<>(minPower);
+		break;
+	case 1:
+		parameterWrapper->set<>(maxPower);
+		break;
+	default:
+		return INVALID_IDENTIFIER_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}

src/core/power/PowerSensor.cpp

@@ -0,0 +1,133 @@
+#include "PowerSensor.h"
+
+#include "../ipc/QueueFactory.h"
+
+PowerSensor::PowerSensor(object_id_t objectId, sid_t setId,  VariableIds ids,
+		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
+		SystemObject(objectId), parameterHelper(this),
+		healthHelper(this, objectId),
+		powerSensorSet(setId), current(ids.pidCurrent, &powerSensorSet),
+		voltage(ids.pidVoltage, &powerSensorSet),
+		power(ids.poolIdPower, &powerSensorSet, PoolVariableIF::VAR_WRITE),
+		currentLimit(objectId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
+				limits.currentMin, limits.currentMax, events.currentLow,
+				events.currentHigh),
+		voltageLimit(objectId, MODULE_ID_VOLTAGE,
+				ids.pidVoltage, confirmationCount, limits.voltageMin,
+				limits.voltageMax, events.voltageLow, events.voltageHigh) {
+		commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+PowerSensor::~PowerSensor() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t PowerSensor::calculatePower() {
+	powerSensorSet.read();
+	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
+	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
+	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
+			&& current.isValid()) {
+		result1 = voltageLimit.doCheck(voltage.value);
+		result2 = currentLimit.doCheck(current.value);
+	} else {
+		voltageLimit.setToInvalid();
+		currentLimit.setToInvalid();
+		result1 = OBJECT_NOT_HEALTHY;
+	}
+	if (result1 != HasReturnvaluesIF::RETURN_OK
+			|| result2 != HasReturnvaluesIF::RETURN_OK) {
+		result1 = MonitoringIF::INVALID;
+		power.setValid(PoolVariableIF::INVALID);
+	} else {
+		power.setValid(PoolVariableIF::VALID);
+		power.value = current.value * voltage.value;
+	}
+	powerSensorSet.commit();
+	return result1;
+}
+
+ReturnValue_t PowerSensor::performOperation(uint8_t opCode) {
+	checkCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t PowerSensor::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t PowerSensor::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();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return result;
+}
+
+void PowerSensor::setAllMonitorsToUnchecked() {
+	currentLimit.setToUnchecked();
+	voltageLimit.setToUnchecked();
+}
+
+void PowerSensor::checkCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = parameterHelper.handleParameterMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	command.setToUnknownCommand();
+	commandQueue->reply(&command);
+}
+
+void PowerSensor::setDataPoolEntriesInvalid() {
+	powerSensorSet.read();
+	powerSensorSet.setValidity(false, true);
+	powerSensorSet.commit();
+}
+
+float PowerSensor::getPower() {
+	if (power.isValid()) {
+		return power.value;
+	} else {
+		return 0.0;
+	}
+
+}
+
+ReturnValue_t PowerSensor::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState PowerSensor::getHealth() {
+	return healthHelper.getHealth();
+}
+
+ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint8_t uniqueId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	ReturnValue_t result = currentLimit.getParameter(domainId, uniqueId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = voltageLimit.getParameter(domainId, uniqueId, parameterWrapper,
+			newValues, startAtIndex);
+	return result;
+}

src/core/power/PowerSwitcher.cpp

@@ -0,0 +1,135 @@
+#include "PowerSwitcher.h"
+
+#include "../objectmanager/ObjectManager.h"
+#include "../serviceinterface/ServiceInterface.h"
+
+PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
+		PowerSwitcher::State_t setStartState):
+		state(setStartState), firstSwitch(setSwitch1),
+		secondSwitch(setSwitch2) {
+}
+
+ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
+	power = ObjectManager::instance()->get<PowerSwitchIF>(powerSwitchId);
+	if (power == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PowerSwitcher::getStateOfSwitches() {
+	SwitchReturn_t result = howManySwitches();
+
+	switch (result) {
+	case ONE_SWITCH:
+		return power->getSwitchState(firstSwitch);
+	case TWO_SWITCHES: {
+	    ReturnValue_t firstSwitchState = power->getSwitchState(firstSwitch);
+	    ReturnValue_t secondSwitchState = power->getSwitchState(firstSwitch);
+		if ((firstSwitchState == PowerSwitchIF::SWITCH_ON)
+				&& (secondSwitchState == PowerSwitchIF::SWITCH_ON)) {
+			return PowerSwitchIF::SWITCH_ON;
+		}
+		else if ((firstSwitchState == PowerSwitchIF::SWITCH_OFF)
+				&& (secondSwitchState  == PowerSwitchIF::SWITCH_OFF)) {
+			return PowerSwitchIF::SWITCH_OFF;
+		}
+		else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
+	SwitchReturn_t result = howManySwitches();
+	switch (result) {
+	case TWO_SWITCHES:
+		power->sendSwitchCommand(secondSwitch, onOff);
+		/* NO BREAK falls through*/
+	case ONE_SWITCH:
+		power->sendSwitchCommand(firstSwitch, onOff);
+		break;
+	}
+	return;
+
+}
+
+void PowerSwitcher::turnOn() {
+	commandSwitches(PowerSwitchIF::SWITCH_ON);
+	state = WAIT_ON;
+}
+
+void PowerSwitcher::turnOff() {
+	commandSwitches(PowerSwitchIF::SWITCH_OFF);
+	state = WAIT_OFF;
+}
+
+PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
+	if (secondSwitch == NO_SWITCH) {
+		return ONE_SWITCH;
+	} else {
+		return TWO_SWITCHES;
+	}
+}
+
+void PowerSwitcher::doStateMachine() {
+	switch (state) {
+	case SWITCH_IS_OFF:
+	case SWITCH_IS_ON:
+		//Do nothing.
+		break;
+	case WAIT_OFF:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
+			state = SWITCH_IS_OFF;
+		}
+		break;
+	case WAIT_ON:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
+			state = SWITCH_IS_ON;
+		}
+		break;
+	default:
+		//Should never happen.
+		break;
+	}
+}
+
+ReturnValue_t PowerSwitcher::checkSwitchState() {
+	switch (state) {
+	case WAIT_OFF:
+	case WAIT_ON:
+		return IN_POWER_TRANSITION;
+	case SWITCH_IS_OFF:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
+			return RETURN_OK;
+		} else {
+			return SWITCH_STATE_MISMATCH;
+		}
+	case SWITCH_IS_ON:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
+			return RETURN_OK;
+		} else {
+			return SWITCH_STATE_MISMATCH;
+		}
+	}
+	return RETURN_FAILED;
+}
+
+PowerSwitcher::State_t PowerSwitcher::getState() {
+	return state;
+}
+
+uint32_t PowerSwitcher::getSwitchDelay() {
+	return power->getSwitchDelayMs();
+}
+
+uint8_t PowerSwitcher::getFirstSwitch() const {
+	return firstSwitch;
+}
+
+uint8_t PowerSwitcher::getSecondSwitch() const {
+	return secondSwitch;
+}