added cmake support for csp lib

bsp_q7s/CMakeLists.txt

@@ -0,0 +1,10 @@
+target_sources(${TARGET_NAME} PUBLIC
+	InitMission.cpp
+	main.cpp
+	ObjectFactory.cpp
+)
+
+add_subdirectory(boardconfig)
+
+
+

bsp_q7s/InitMission.cpp

@@ -0,0 +1,178 @@
+#include "InitMission.h"
+#include "ObjectFactory.h"
+#include <OBSWConfig.h>
+
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+#include <fsfw/tasks/PeriodicTaskIF.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfwconfig/pollingsequence/PollingSequenceFactory.h>
+
+#include <iostream>
+
+// This is configured for linux without \cr
+#ifdef LINUX
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR", false, false, true);
+#else
+ServiceInterfaceStream sif::debug("DEBUG", true);
+ServiceInterfaceStream sif::info("INFO", true);
+ServiceInterfaceStream sif::warning("WARNING", true);
+ServiceInterfaceStream sif::error("ERROR", true, false, true);
+#endif
+
+ObjectManagerIF *objectManager = nullptr;
+
+void InitMission::initMission() {
+	sif::info << "Building global objects.." << std::endl;
+	/* Instantiate global object manager and also create all objects */
+    objectManager = new ObjectManager(ObjectFactory::produce);
+    sif::info << "Initializing all objects.." << std::endl;
+    objectManager->initialize();
+
+    /* This function creates and starts all tasks */
+    initTasks();
+}
+
+void InitMission::initTasks(){
+	/* TMTC Distribution */
+	PeriodicTaskIF* TmTcDistributor = TaskFactory::instance()->
+			createPeriodicTask("DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE,
+					0.100, nullptr);
+	ReturnValue_t result = TmTcDistributor->addComponent(
+			objects::CCSDS_PACKET_DISTRIBUTOR);
+	if(result!=HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+	result = TmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
+	if(result!=HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+    result = TmTcDistributor->addComponent(objects::TM_FUNNEL);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+    	sif::error << "Object add component failed" << std::endl;
+    }
+
+    /* UDP bridge */
+    PeriodicTaskIF* UdpBridgeTask = TaskFactory::instance()->createPeriodicTask(
+    		"UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE,
+			0.2, nullptr);
+    result = UdpBridgeTask->addComponent(objects::UDP_BRIDGE);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+    	sif::error << "Add component UDP Unix Bridge failed" << std::endl;
+    }
+    PeriodicTaskIF* UdpPollingTask = TaskFactory::instance()->
+    		createPeriodicTask("UDP_POLLING", 80,
+    		PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, nullptr);
+    result = UdpPollingTask->addComponent(objects::UDP_POLLING_TASK);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+    	sif::error << "Add component UDP Polling failed" << std::endl;
+    }
+
+	/* PUS Services */
+	PeriodicTaskIF* PusVerification = TaskFactory::instance()->
+			createPeriodicTask("PUS_VERIF_1", 40,
+					PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, nullptr);
+	result = PusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+
+	PeriodicTaskIF* PusEvents = TaskFactory::instance()->
+			createPeriodicTask("PUS_VERIF_1", 60,
+					PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, nullptr);
+	result = PusVerification->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+
+	PeriodicTaskIF* PusHighPrio = TaskFactory::instance()->
+			createPeriodicTask("PUS_HIGH_PRIO", 50,
+					PeriodicTaskIF::MINIMUM_STACK_SIZE,
+					0.200, nullptr);
+	result = PusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
+	if(result!=HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+	result = PusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+	if(result!=HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+
+	PeriodicTaskIF* PusMedPrio = TaskFactory::instance()->
+			createPeriodicTask("PUS_HIGH_PRIO", 40,
+					PeriodicTaskIF::MINIMUM_STACK_SIZE,
+					0.8, nullptr);
+	result = PusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
+	if(result!=HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+	result = PusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
+	if(result!=HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+
+	PeriodicTaskIF* PusLowPrio = TaskFactory::instance()->
+			createPeriodicTask("PUSB", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE,
+					1.6, nullptr);
+	result = PusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+	if(result!=HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+
+//	PeriodicTaskIF* P60DockTask = TaskFactory::instance()->
+//			createPeriodicTask("P60Dock Task", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE*4,
+//					1.6, nullptr);
+//	result = P60DockTask->addComponent(objects::P60DOCK_HANDLER);
+//	if(result!=HasReturnvaluesIF::RETURN_OK){
+//		sif::error << "Object add component failed" << std::endl;
+//	}
+
+	FixedTimeslotTaskIF* GomSpacePstTask = TaskFactory::instance()->
+			createFixedTimeslotTask("GS_PST_TASK", 50,
+					PeriodicTaskIF::MINIMUM_STACK_SIZE*4, 1.0, nullptr);
+	result = pst::gomspacePstInit(GomSpacePstTask);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "InitMission::initTasks: GomSpace PST initialization "
+				<< "failed!" << std::endl;
+}
+
+
+#if OBSW_ADD_TEST_CODE == 1
+//	FixedTimeslotTaskIF* TestTimeslotTask = TaskFactory::instance()->
+//			createFixedTimeslotTask("PST_TEST_TASK", 10,
+//					PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, nullptr);
+//	result = pst::pollingSequenceTestFunction(TestTimeslotTask);
+//	if(result != HasReturnvaluesIF::RETURN_OK) {
+//		sif::error << "InitMission::createTasks: Test PST initialization "
+//				<< "failed!" << std::endl;
+//	}
+
+#endif
+
+	//Main thread sleep
+	sif::info << "Starting tasks.." << std::endl;
+	TmTcDistributor->startTask();
+	UdpBridgeTask->startTask();
+	UdpPollingTask->startTask();
+
+	GomSpacePstTask->startTask();
+
+	PusVerification->startTask();
+	PusEvents->startTask();
+	PusHighPrio->startTask();
+	PusMedPrio->startTask();
+	PusLowPrio->startTask();
+
+//	P60DockTask->startTask();
+
+#if OBSW_ADD_TEST_CODE == 1
+//	TestTimeslotTask->startTask();
+#endif
+	sif::info << "Tasks started.." << std::endl;
+}

bsp_q7s/InitMission.h

@@ -0,0 +1,9 @@
+#ifndef BSP_Q7S_INITMISSION_H_
+#define BSP_Q7S_INITMISSION_H_
+
+namespace InitMission {
+void initMission();
+void initTasks();
+};
+
+#endif /* BSP_Q7S_INITMISSION_H_ */

bsp_q7s/ObjectFactory.cpp

@@ -0,0 +1,77 @@
+#include "ObjectFactory.h"
+#include <OBSWConfig.h>
+#include <tmtc/apid.h>
+#include <devices/addresses.h>
+#include <tmtc/pusIds.h>
+
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
+#include <fsfw/osal/linux/TmTcUnixUdpBridge.h>
+#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
+#include <fsfw/osal/linux/TcUnixUdpPollingTask.h>
+
+#include <mission/core/GenericFactory.h>
+#include <mission/devices/GomspaceDeviceHandler.h>
+#include <mission/devices/devicedefinitions/GomSpacePackets.h>
+#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
+#include <mission/utility/TmFunnel.h>
+
+#include <bsp_q7s/comIF/cookies/CspCookie.h>
+#include <bsp_q7s/comIF/CspComIF.h>
+
+void Factory::setStaticFrameworkObjectIds() {
+	PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
+	PusServiceBase::packetDestination = objects::TM_FUNNEL;
+
+	CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
+	CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+
+	TmFunnel::downlinkDestination = objects::UDP_BRIDGE;
+	// No storage object for now.
+	TmFunnel::storageDestination = objects::NO_OBJECT;
+
+	LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
+
+	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+	TmPacketStored::timeStamperId = objects::TIME_STAMPER;
+}
+
+
+
+void ObjectFactory::produce(){
+	Factory::setStaticFrameworkObjectIds();
+	ObjectFactory::produceGenericObjects();
+
+    /* Cookies */
+	CspCookie* p60DockCspCookie = new CspCookie(P60Dock::MAX_REPLY_LENGTH,
+			addresses::P60DOCK);
+	CspCookie* pdu1CspCookie = new CspCookie(PDU::MAX_REPLY_LENGTH,
+			addresses::PDU1);
+	CspCookie* pdu2CspCookie = new CspCookie(PDU::MAX_REPLY_LENGTH,
+			addresses::PDU2);
+	CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_LENGTH,
+				addresses::ACU);
+
+    /* Communication interfaces */
+	new CspComIF(objects::CSP_COM_IF);
+
+    /* Device Handler */
+	new GomspaceDeviceHandler(objects::P60DOCK_HANDLER, objects::CSP_COM_IF,
+			p60DockCspCookie, P60Dock::MAX_CONFIGTABLE_ADDRESS,
+			P60Dock::MAX_HKTABLE_ADDRESS);
+	new GomspaceDeviceHandler(objects::PDU1_HANDLER, objects::CSP_COM_IF,
+			pdu1CspCookie, PDU::MAX_CONFIGTABLE_ADDRESS,
+			PDU::MAX_HKTABLE_ADDRESS);
+	new GomspaceDeviceHandler(objects::PDU2_HANDLER, objects::CSP_COM_IF,
+			pdu2CspCookie, PDU::MAX_CONFIGTABLE_ADDRESS,
+			PDU::MAX_HKTABLE_ADDRESS);
+	new GomspaceDeviceHandler(objects::ACU_HANDLER, objects::CSP_COM_IF,
+				acuCspCookie, ACU::MAX_CONFIGTABLE_ADDRESS,
+				ACU::MAX_HKTABLE_ADDRESS);
+
+	new TmTcUnixUdpBridge(objects::UDP_BRIDGE,
+			objects::CCSDS_PACKET_DISTRIBUTOR,
+			objects::TM_STORE, objects::TC_STORE);
+	new TcUnixUdpPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
+}

bsp_q7s/ObjectFactory.h

@@ -0,0 +1,10 @@
+#ifndef BSP_Q7S_OBJECTFACTORY_H_
+#define BSP_Q7S_OBJECTFACTORY_H_
+
+
+namespace ObjectFactory {
+	void setStatics();
+	void produce();
+};
+
+#endif /* BSP_Q7S_OBJECTFACTORY_H_ */

bsp_q7s/boardconfig/CMakeLists.txt

@@ -0,0 +1,10 @@
+target_sources(${TARGET_NAME} PRIVATE
+	print.c
+)
+
+target_include_directories(${TARGET_NAME} PUBLIC
+	${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+
+

bsp_q7s/boardconfig/etl_profile.h

@@ -0,0 +1,38 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2019 jwellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+#ifndef __ETL_PROFILE_H__
+#define __ETL_PROFILE_H__
+
+#define ETL_CHECK_PUSH_POP
+
+#define ETL_CPP11_SUPPORTED  1
+#define ETL_NO_NULLPTR_SUPPORT  0
+
+#endif

bsp_q7s/boardconfig/gcov.h

@@ -0,0 +1,14 @@
+#ifndef LINUX_GCOV_H_
+#define LINUX_GCOV_H_
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+
+#ifdef GCOV
+extern "C" void __gcov_flush();
+#else
+void __gcov_flush() {
+	sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
+			"coverage information is desired.\n" << std::flush;
+}
+#endif
+
+#endif /* LINUX_GCOV_H_ */

bsp_q7s/boardconfig/print.c

@@ -0,0 +1,14 @@
+#include <bsp_q7s/boardconfig/print.h>
+#include <stdio.h>
+
+void printChar(const char* character, bool errStream) {
+	if(errStream) {
+		putc(*character, stderr);
+		return;
+	}
+	putc(*character, stdout);
+}
+
+
+
+

bsp_q7s/boardconfig/print.h

@@ -0,0 +1,8 @@
+#ifndef HOSTED_BOARDCONFIG_PRINT_H_
+#define HOSTED_BOARDCONFIG_PRINT_H_
+
+#include <stdbool.h>
+
+void printChar(const char* character, bool errStream);
+
+#endif /* HOSTED_BOARDCONFIG_PRINT_H_ */

bsp_q7s/bsp_q7s.mk

@@ -0,0 +1,6 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/comIF/cookies/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/comIF/*.cpp)
+CSRC += $(wildcard $(CURRENTPATH)/*.c)
+
+CSRC += $(wildcard $(CURRENTPATH)/boardconfig/*.c)

bsp_q7s/comIF/CspComIF.cpp

@@ -0,0 +1,212 @@
+#include "CspComIF.h"
+#include "cookies/CspCookie.h"
+
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <csp/drivers/can_socketcan.h>
+#include <fsfw/serialize/SerializeAdapter.h>
+
+CspComIF::CspComIF(object_id_t objectId) :
+		SystemObject(objectId) {
+
+}
+
+CspComIF::~CspComIF() {
+}
+
+ReturnValue_t CspComIF::initializeInterface(CookieIF *cookie)  {
+	if(cookie == nullptr) {
+		return NULLPOINTER;
+	}
+
+	CspCookie* cspCookie = dynamic_cast<CspCookie*>(cookie);
+	if(cspCookie == nullptr) {
+		return NULLPOINTER;
+	}
+
+	/* Perform CAN and CSP initialization only once */
+	if(cspDeviceMap.empty()){
+		/* Define the memory to allocate for the CSP stack */
+		int buf_count = 10;
+		int buf_size = 300;
+		/* Init CSP and CSP buffer system */
+		if (csp_init(cspClientAddress) != CSP_ERR_NONE
+				|| csp_buffer_init(buf_count, buf_size) != CSP_ERR_NONE) {
+			sif::error << "Failed to init CSP\r\n" << std::endl;
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+		int promisc = 0; // Set filter mode on
+		csp_iface_t *csp_if_ptr = &csp_if;
+		csp_if_ptr = csp_can_socketcan_init(canInterface, bitrate, promisc);
+
+		/* Set default route and start router */
+		uint8_t address = CSP_DEFAULT_ROUTE;
+		uint8_t netmask = 0;
+		uint8_t mac = CSP_NODE_MAC;
+		int result = csp_rtable_set(address, netmask, csp_if_ptr, mac);
+		if(result != CSP_ERR_NONE){
+			sif::error << "Failed to add can interface to router table"
+					<< std::endl;
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+		/* Start the route task */
+		unsigned int task_stack_size = 500;
+		unsigned int priority = 0;
+		result = csp_route_start_task(task_stack_size, priority);
+		if(result != CSP_ERR_NONE){
+			sif::error << "Failed to start csp route task" << std::endl;
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+
+	uint8_t cspAddress = cspCookie->getCspAddress();
+	uint16_t maxReplyLength = cspCookie->getMaxReplyLength();
+	if(cspDeviceMap.find(cspAddress) == cspDeviceMap.end()){
+		/* Insert device information in CSP map */
+		cspDeviceMap.emplace(cspAddress, vectorBuffer(maxReplyLength));
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CspComIF::sendMessage(CookieIF *cookie,
+		const uint8_t * sendData, size_t sendLen) {
+	int result;
+	if(cookie == NULL){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	CspCookie* cspCookie = dynamic_cast<CspCookie*> (cookie);
+	if(cspCookie == NULL){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	/* Extract csp port and bytes to query from command buffer */
+	uint8_t cspPort;
+	uint16_t querySize;
+	result = getPortAndQuerySize(&sendData, &sendLen, &cspPort, &querySize);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	uint8_t cspAddress = cspCookie->getCspAddress();
+	switch(cspPort) {
+	case(Ports::CSP_PING): {
+		initiatePingRequest(cspAddress, querySize);
+		break;
+	}
+	case(Ports::CSP_REBOOT): {
+		csp_reboot(cspAddress);
+		break;
+	}
+	case(Ports::P60_PORT_GNDWDT_RESET):
+	case(Ports::P60_PORT_RPARAM): {
+		/* No CSP fixed port was selected. Send data to the specified port and
+		 * wait for querySize number of bytes */
+		result = cspTransfer(cspAddress, cspPort, sendData, sendLen,
+				querySize);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		replySize = querySize;
+		break;
+	}
+	default:
+		sif::error << "CspComIF: Invalid port specified" << std::endl;
+		break;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CspComIF::getSendSuccess(CookieIF *cookie) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CspComIF::requestReceiveMessage(CookieIF *cookie,
+		size_t requestLen) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CspComIF::readReceivedMessage(CookieIF *cookie,
+		uint8_t** buffer, size_t* size) {
+	if(cookie == NULL){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	CspCookie* cspCookie = dynamic_cast<CspCookie*> (cookie);
+	if(cspCookie == NULL){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint8_t cspAddress = cspCookie->getCspAddress();
+
+	*buffer = cspDeviceMap[cspAddress].data();
+	*size = replySize;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CspComIF::cspTransfer(uint8_t cspAddress, uint8_t cspPort,
+		const uint8_t* cmdBuffer, int cmdBufferLen, uint16_t querySize) {
+
+	uint32_t timeout_ms = 500;
+	vectorBufferIter iter = cspDeviceMap.find(cspAddress);
+	if(iter == cspDeviceMap.end()){
+		sif::error << "CSP device with address " << cspAddress << " no found in"
+				<< " device map" << std::endl;
+	}
+	uint8_t* replyBuffer = iter->second.data();
+	uint8_t tmpCmdBuffer[cmdBufferLen];
+	memcpy(tmpCmdBuffer, cmdBuffer, cmdBufferLen);
+
+	csp_conn_t * conn = csp_connect(CSP_PRIO_HIGH, cspAddress, cspPort, 0,
+			CSP_O_NONE);
+
+	int result = csp_transaction_persistent(conn, timeout_ms,
+			tmpCmdBuffer, cmdBufferLen, replyBuffer, querySize);
+	if(querySize != 0){
+		if(result != querySize){
+			sif::error << "CSP transfer failed to receive all requested bytes "
+					   << std::endl;
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	} else {
+		if(result != 1){
+			sif::error << "CSP transfer failed" << std::endl;
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+
+	csp_close(conn);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CspComIF::getPortAndQuerySize(const uint8_t** sendData,
+		size_t* sendLen, uint8_t* cspPort, uint16_t* querySize) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(cspPort, sendData,
+			sendLen, SerializeIF::Endianness::BIG);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "CspComIF: Failed to deserialize CSP port from command "
+				<< "buffer" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	SerializeAdapter::deSerialize(querySize, sendData, sendLen,
+			SerializeIF::Endianness::BIG);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "CspComIF: Failed to deserialize querySize from command "
+				<< "buffer" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void CspComIF::initiatePingRequest(uint8_t cspAddress, uint16_t querySize){
+	uint32_t timeout_ms = 500;
+	uint32_t replyTime = csp_ping(cspAddress, timeout_ms, querySize,
+			CSP_O_NONE);
+	sif::info << "Ping address: " << cspAddress << ", reply after "
+			<< replyTime << " ms" << std::endl;
+	/* Store reply time in reply buffer * */
+	uint8_t* replyBuffer = cspDeviceMap[cspAddress].data();
+	memcpy(replyBuffer, &replyTime, sizeof(replyTime));
+	replySize = sizeof(replyTime);
+}

bsp_q7s/comIF/CspComIF.h

@@ -0,0 +1,89 @@
+#ifndef BSP_LINUX_COMIF_COOKIES_CSPCOMIF_H_
+#define BSP_LINUX_COMIF_COOKIES_CSPCOMIF_H_
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <csp/csp.h>
+
+#include <vector>
+#include <unordered_map>
+
+/**
+ * @brief	This class serves as the communication interface to devices
+ * 			supporting the CSP protocol. As physical layer can0 is used
+ * 			in this implementation.
+ * @author	J. Meier
+ */
+class CspComIF: public DeviceCommunicationIF, public SystemObject {
+public:
+	CspComIF(object_id_t objectId);
+	virtual ~CspComIF();
+
+	ReturnValue_t initializeInterface(CookieIF * cookie) override;
+	ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
+			size_t sendLen) override;
+	ReturnValue_t getSendSuccess(CookieIF *cookie) override;
+	ReturnValue_t requestReceiveMessage(CookieIF *cookie,
+			size_t requestLen) override;
+	ReturnValue_t readReceivedMessage(CookieIF *cookie,
+			uint8_t **readData, size_t *readLen) override;
+
+private:
+
+	/**
+	 * @brief	This function initiates the CSP transfer.
+	 *
+	 * @param cspAddress	The CSP address of the target device.
+	 * @param cspPort		The port of the target device.
+	 * @param timeout		The timeout to wait for csp_send and csp_read
+	 * 						functions. Specifies how long the functions wait
+	 * 						for a successful operation.
+	 * @param cmdBuffer		The data to send.
+	 * @param cmpBuffer		The number of bytes to send.
+	 * @param querySize		The size of the requested message.
+	 */
+	ReturnValue_t cspTransfer(uint8_t cspAddress, uint8_t cspPort,
+			const uint8_t* cmdBuffer, int cmdBufferLen, uint16_t querySize);
+
+	enum Ports {
+		CSP_PING = 1,
+		CSP_REBOOT = 4,
+		P60_PORT_RPARAM = 7,
+		P60_PORT_GNDWDT_RESET = 9
+	};
+
+
+	typedef uint8_t node_t;
+	using vectorBuffer = std::vector<uint8_t>;
+	using VectorBufferMap = std::unordered_map<node_t, vectorBuffer>;
+	using vectorBufferIter = VectorBufferMap::iterator;
+
+	/* In this map assigns reply buffers to a CSP device */
+	VectorBufferMap cspDeviceMap;
+
+	uint16_t replySize = 0;
+
+	/* This is the CSP address of the OBC. */
+	node_t cspClientAddress = 1;
+
+	/* Interface struct for csp protocol stack */
+	csp_iface_t csp_if;
+
+	char canInterface[5] = "can0";
+	int bitrate = 1000;
+
+	/**
+	 * @brief	Function to extract the csp port and the query size from the
+	 * 			command buffer.
+	 */
+	ReturnValue_t getPortAndQuerySize(const uint8_t** sendData, size_t* sendLen,
+			uint8_t* cspPort, uint16_t* querySize);
+
+	/**
+	 * @brief	This function initiates the ping request.
+	 */
+	void initiatePingRequest(uint8_t cspAddress, uint16_t querySize);
+};
+
+#endif /* BSP_LINUX_COMIF_COOKIES_CSPCOMIF_H_ */

bsp_q7s/comIF/cookies/CspCookie.cpp

@@ -0,0 +1,16 @@
+#include "CspCookie.h"
+
+CspCookie::CspCookie(uint16_t maxReplyLength_, uint8_t cspAddress_) :
+		maxReplyLength(maxReplyLength_), cspAddress(cspAddress_) {
+}
+
+CspCookie::~CspCookie() {
+}
+
+uint16_t CspCookie::getMaxReplyLength(){
+	return maxReplyLength;
+}
+
+uint8_t CspCookie::getCspAddress(){
+	return cspAddress;
+}

bsp_q7s/comIF/cookies/CspCookie.h

@@ -0,0 +1,27 @@
+#ifndef BSP_Q7S_COMIF_COOKIES_CSPCOOKIE_H_
+#define BSP_Q7S_COMIF_COOKIES_CSPCOOKIE_H_
+
+#include <fsfw/devicehandlers/CookieIF.h>
+#include <cstdint>
+
+/**
+ * @brief	This is the cookie for devices supporting the CSP (CubeSat Space
+ * 			Protocol).
+ * @author	J. Meier
+ */
+class CspCookie: public CookieIF {
+public:
+
+	CspCookie(uint16_t maxReplyLength_, uint8_t cspAddress_);
+	virtual ~CspCookie();
+
+	uint16_t getMaxReplyLength();
+	uint8_t getCspAddress();
+
+private:
+
+	uint16_t maxReplyLength;
+	uint8_t cspAddress;
+};
+
+#endif /* BSP_Q7S_COMIF_COOKIES_CSPCOOKIE_H_ */

bsp_q7s/main.cpp

@@ -0,0 +1,29 @@
+#include "InitMission.h"
+#include <OBSWVersion.h>
+#include <fsfw/tasks/TaskFactory.h>
+
+#include <iostream>
+
+#include <unistd.h>
+
+/**
+ * @brief 	This is the main program for the target hardware.
+ * @return
+ */
+int main(void)
+{
+    std::cout << "-- EIVE OBSW --" << std::endl;
+    std::cout << "-- Compiled for Linux " << " --" << std::endl;
+    std::cout << "-- Software version " << SW_NAME << " v" << SW_VERSION << "."
+    		<< SW_SUBVERSION << "." << SW_SUBSUBVERSION << " -- " << std::endl;
+    std::cout << "-- " <<  __DATE__ << " " << __TIME__ << " --" << std::endl;
+
+	InitMission::initMission();
+
+	for(;;) {
+		// suspend main thread by sleeping it.
+		TaskFactory::delayTask(5000);
+	}
+}
+
+