fsfw/devicehandlers/DeviceHandlerBase.cpp

#include "DeviceHandlerBase.h"
#include "AcceptsDeviceResponsesIF.h"
#include "DeviceTmReportingWrapper.h"

#include "../serviceinterface/ServiceInterface.h"
#include "../objectmanager/ObjectManager.h"
#include "../storagemanager/StorageManagerIF.h"
#include "../thermal/ThermalComponentIF.h"
#include "../globalfunctions/CRC.h"
#include "../housekeeping/HousekeepingMessage.h"
#include "../ipc/MessageQueueMessage.h"
#include "../ipc/QueueFactory.h"
#include "../subsystem/SubsystemBase.h"
#include "../datapoollocal/LocalPoolVariable.h"

object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;

DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
		object_id_t deviceCommunication, CookieIF * comCookie,
		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
		actionHelper(this, nullptr), poolManager(this, nullptr),
		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
		switchOffWasReported(false), childTransitionDelay(5000),
		transitionSourceMode(_MODE_POWER_DOWN),
		transitionSourceSubMode(SUBMODE_NONE) {
	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
			MessageQueueMessage::MAX_MESSAGE_SIZE);
	insertInCommandMap(RAW_COMMAND_ID);
	cookieInfo.state = COOKIE_UNUSED;
	cookieInfo.pendingCommand = deviceCommandMap.end();
	if (comCookie == nullptr) {
		printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
				HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
	}
	if (this->fdirInstance == nullptr) {
		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
				defaultFdirParentId);
	}
}

void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
	this->hkDestination = hkDestination;
}

void DeviceHandlerBase::setThermalStateRequestPoolIds(
		lp_id_t thermalStatePoolId, lp_id_t heaterRequestPoolId,
		uint32_t thermalSetId) {
	thermalSet = new DeviceHandlerThermalSet(this, thermalSetId,
			thermalStatePoolId, heaterRequestPoolId);
}


DeviceHandlerBase::~DeviceHandlerBase() {
	delete comCookie;
	if (defaultFDIRUsed) {
		delete fdirInstance;
	}
	QueueFactory::instance()->deleteMessageQueue(commandQueue);
}

ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
	this->pstStep = counter;
	this->lastStep = this->pstStep;

	if (getComAction() == CommunicationAction::NOTHING) {
	    return HasReturnvaluesIF::RETURN_OK;
	}

	if (getComAction() == CommunicationAction::PERFORM_OPERATION) {
		cookieInfo.state = COOKIE_UNUSED;
		readCommandQueue();
		doStateMachine();
		checkSwitchState();
		decrementDeviceReplyMap();
		fdirInstance->checkForFailures();
		hkSwitcher.performOperation();
		performOperationHook();
		return RETURN_OK;
	}

	if (mode == MODE_OFF) {
		return RETURN_OK;
	}

	switch (getComAction()) {
	case CommunicationAction::SEND_WRITE:
		if (cookieInfo.state == COOKIE_UNUSED) {
		    // if no external command was specified, build internal command.
			buildInternalCommand();
		}
		doSendWrite();
		break;
	case CommunicationAction::GET_WRITE:
		doGetWrite();
		break;
	case CommunicationAction::SEND_READ:
		doSendRead();
		break;
	case CommunicationAction::GET_READ:
		doGetRead();
		// This will be performed after datasets have been updated by the
		// custom device implementation.
		poolManager.performHkOperation();
		break;
	default:
		break;
	}
	return RETURN_OK;
}

ReturnValue_t DeviceHandlerBase::initialize() {
	ReturnValue_t result = SystemObject::initialize();
	if (result != RETURN_OK) {
		return result;
	}

	communicationInterface = objectManager->get<DeviceCommunicationIF>(
			deviceCommunicationId);
	if (communicationInterface == nullptr) {
		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
				ObjectManagerIF::CHILD_INIT_FAILED,
				"Passed communication IF invalid");
		return ObjectManagerIF::CHILD_INIT_FAILED;
	}

	result = communicationInterface->initializeInterface(comCookie);
	if (result != RETURN_OK) {
		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
				ObjectManagerIF::CHILD_INIT_FAILED,
				"ComIF initialization failed");
	    return result;
	}

	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
	if (IPCStore == nullptr) {
		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
				ObjectManagerIF::CHILD_INIT_FAILED, "IPC Store not set up");
		return ObjectManagerIF::CHILD_INIT_FAILED;
	}

	if(rawDataReceiverId != objects::NO_OBJECT) {
		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
				AcceptsDeviceResponsesIF>(rawDataReceiverId);

		if (rawReceiver == nullptr) {
			printWarningOrError(sif::OutputTypes::OUT_ERROR,
					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
					"Raw receiver object ID set but no valid object found.");
#if FSFW_CPP_OSTREAM_ENABLED == 1
			sif::error << "Make sure the raw receiver object is set up properly"
					" and implements AcceptsDeviceResponsesIF" << std::endl;
#else
			sif::printError("Make sure the raw receiver object is set up "
					"properly and implements AcceptsDeviceResponsesIF\n");
#endif
			return ObjectManagerIF::CHILD_INIT_FAILED;
		}
		defaultRawReceiver = rawReceiver->getDeviceQueue();
	}

	if(powerSwitcherId != objects::NO_OBJECT) {
		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
		if (powerSwitcher == nullptr) {