moved stuff to linux folder

linux/CMakeLists.txt

@@ -1,2 +1,4 @@
 add_subdirectory(gpio)
+add_subdirectory(i2c)
+add_subdirectory(csp)
 

linux/csp/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_sources(${TARGET_NAME} PUBLIC
+	CspComIF.cpp
+	CspCookie.cpp
+)
+
+
+
+

linux/csp/CspComIF.cpp

@@ -0,0 +1,255 @@
+#include "CspComIF.h"
+#include "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 cmdLen, uint16_t querySize) {
+
+	uint32_t timeout_ms = 1000;
+	uint16_t bytesRead = 0;
+	int32_t expectedSize = (int32_t)querySize;
+	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();
+
+	csp_conn_t * conn = csp_connect(CSP_PRIO_HIGH, cspAddress, cspPort, 0,
+			CSP_O_NONE);
+
+    csp_packet_t* commandPacket = (csp_packet_t*)csp_buffer_get(cmdLen);
+    if (commandPacket == NULL) {
+        sif::error << "CspComIF::cspTransfer: Failed to get memory for a csp packet from the csp "
+                << "stack" << std::endl;
+        csp_close(conn);
+        return RETURN_FAILED;
+    }
+
+    memcpy(commandPacket->data, cmdBuffer, cmdLen);
+    commandPacket->length = cmdLen;
+
+    if (!csp_send(conn, commandPacket, timeout_ms)) {
+        csp_buffer_free(commandPacket);
+        sif::error << "CspComIF::cspTransfer: Failed to send csp packet" << std::endl;
+        csp_close(conn);
+        return RETURN_FAILED;
+    }
+
+    /* Return when no reply is expected */
+    if (expectedSize == 0) {
+        return RETURN_OK;
+    }
+
+    csp_packet_t * reply;
+    reply = csp_read(conn, timeout_ms);
+    if (reply == NULL) {
+        sif::error << "CspComIF::cspTransfer: Failed to read csp packet" << std::endl;
+        csp_close(conn);
+        return RETURN_FAILED;
+    }
+    memcpy(replyBuffer, reply->data, reply->length);
+    expectedSize = expectedSize - reply->length;
+    bytesRead += reply->length;
+    csp_buffer_free(reply);
+    while (expectedSize > 0) {
+        reply = csp_read(conn, timeout_ms);
+        if (reply == NULL) {
+            sif::error << "CspComIF::cspTransfer: Failed to read csp packet" << std::endl;
+            csp_close(conn);
+            return RETURN_FAILED;
+        }
+        if ((reply->length + bytesRead) > iter->second.size()) {
+            sif::error << "CspComIF::cspTransfer: Reply buffer to short" << std::endl;
+            csp_buffer_free(reply);
+            csp_close(conn);
+            return RETURN_FAILED;
+        }
+        memcpy(replyBuffer + bytesRead, reply->data, reply->length);
+        expectedSize = expectedSize - reply->length;
+        bytesRead += reply->length;
+        csp_buffer_free(reply);
+    }
+
+	if(expectedSize != 0){
+        sif::error << "CspComIF::cspTransfer: Received more bytes than requested" << std::endl;
+        csp_close(conn);
+        return 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);
+}

linux/csp/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 cmdLen   		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 cmdLen, 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_ */

linux/csp/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;
+}

linux/csp/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_ */

linux/i2c/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_sources(${TARGET_NAME} PUBLIC
+	I2cComIF.cpp
+	I2cCookie.cpp
+)
+
+
+
+

linux/i2c/I2cComIF.cpp

@@ -0,0 +1,204 @@
+#include "I2cComIF.h"
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/i2c-dev.h>
+#include <errno.h>
+#include <string.h>
+
+
+I2cComIF::I2cComIF(object_id_t objectId): SystemObject(objectId){
+}
+
+I2cComIF::~I2cComIF() {}
+
+ReturnValue_t I2cComIF::initializeInterface(CookieIF * cookie) {
+
+	address_t i2cAddress;
+	std::string deviceFile;
+
+	if(cookie == nullptr) {
+		return NULLPOINTER;
+	}
+	I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+	if(i2cCookie == nullptr) {
+	    sif::error << "I2cComIF: Invalid I2C Cookie!"
+	            << std::endl;
+	    return NULLPOINTER;
+	}
+
+	i2cAddress = i2cCookie->getAddress();
+
+	i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+	if(i2cDeviceMapIter == i2cDeviceMap.end()) {
+		size_t maxReplyLen = i2cCookie->getMaxReplyLen();
+		I2cInstance_t i2cInstance = {std::vector<uint8_t>(maxReplyLen), 0};
+		std::pair status = i2cDeviceMap.emplace(i2cAddress, i2cInstance);
+		if (status.second == false) {
+			sif::error << "I2cComIF::initializeInterface: Failed to insert "
+					<< "device with address " << i2cAddress << "to I2C device "
+					<< "map" << std::endl;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+	else {
+		sif::error << "I2cComIF: Device with address " << i2cAddress
+				<< "already in use" << std::endl;
+	}
+
+	i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+	if(i2cDeviceMapIter == i2cDeviceMap.end()) {
+		sif::error << "Failure" << std::endl;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t I2cComIF::sendMessage(CookieIF *cookie,
+        const uint8_t *sendData, size_t sendLen) {
+
+	ReturnValue_t result;
+	int fd;
+	std::string deviceFile;
+
+	if(sendData == nullptr) {
+	    sif::error << "I2cComIF::sendMessage: Send Data is nullptr"
+	            << std::endl;
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(sendLen == 0) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+	if(i2cCookie == nullptr) {
+		sif::error << "I2cComIF::sendMessasge: Invalid I2C Cookie!"
+				<< std::endl;
+		return NULLPOINTER;
+	}
+
+	address_t i2cAddress = i2cCookie->getAddress();
+	i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+	if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+		sif::error << "I2cComIF::sendMessage: i2cAddress of Cookie not "
+				<< "registered in i2cDeviceMap" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	deviceFile = i2cCookie->getDeviceFile();
+	result = openDevice(deviceFile, i2cAddress, &fd);
+	if (result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+
+	if (write(fd, sendData, sendLen) != (int)sendLen) {
+		sif::error << "I2cComIF::sendMessage: Failed to send data to I2C "
+				"device with error code " << errno << ". Error description: "
+				<< strerror(errno) << std::endl;
+		close(fd);
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	close(fd);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t I2cComIF::getSendSuccess(CookieIF *cookie) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF *cookie,
+		size_t requestLen) {
+
+	ReturnValue_t result;
+	int fd;
+	std::string deviceFile;
+
+	if (requestLen == 0) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+	if(i2cCookie == nullptr) {
+		sif::error << "I2cComIF::requestReceiveMessage: Invalid I2C Cookie!"
+				<< std::endl;
+		i2cDeviceMapIter->second.replyLen = 0;
+		return NULLPOINTER;
+	}
+
+	address_t i2cAddress = i2cCookie->getAddress();
+	i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+	if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+		sif::error << "I2cComIF::requestReceiveMessage: i2cAddress of Cookie not "
+				<< "registered in i2cDeviceMap" << std::endl;
+		i2cDeviceMapIter->second.replyLen = 0;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	deviceFile = i2cCookie->getDeviceFile();
+	result = openDevice(deviceFile, i2cAddress, &fd);
+	if (result != HasReturnvaluesIF::RETURN_OK){
+		i2cDeviceMapIter->second.replyLen = 0;
+		return result;
+	}
+
+	uint8_t* replyBuffer = i2cDeviceMapIter->second.replyBuffer.data();
+
+	if (read(fd, replyBuffer, requestLen) != (int)requestLen) {
+		sif::error << "I2cComIF::requestReceiveMessage: Reading from I2C "
+				<< "device failed with error code " << errno <<". Description"
+				<< " of error: " << strerror(errno) << std::endl;
+		close(fd);
+		i2cDeviceMapIter->second.replyLen = 0;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	i2cDeviceMapIter->second.replyLen = requestLen;
+
+	close(fd);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t I2cComIF::readReceivedMessage(CookieIF *cookie,
+		uint8_t **buffer, size_t* size) {
+	I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+	if(i2cCookie == nullptr) {
+		sif::error << "I2cComIF::readReceivedMessage: Invalid I2C Cookie!"
+				<< std::endl;
+		return NULLPOINTER;
+	}
+
+	address_t i2cAddress = i2cCookie->getAddress();
+	i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+	if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+		sif::error << "I2cComIF::readReceivedMessage: i2cAddress of Cookie not "
+				<< "found in i2cDeviceMap" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	*buffer = i2cDeviceMapIter->second.replyBuffer.data();
+	*size = i2cDeviceMapIter->second.replyLen;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t I2cComIF::openDevice(std::string deviceFile,
+		address_t i2cAddress, int* fileDescriptor) {
+	*fileDescriptor = open(deviceFile.c_str(), O_RDWR);
+	if (*fileDescriptor < 0) {
+		sif::error << "I2cComIF: Opening i2c device failed with error code "
+				<< errno << ". Error description: " << strerror(errno)
+				<< std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if (ioctl(*fileDescriptor, I2C_SLAVE, i2cAddress) < 0) {
+		sif::error << "I2cComIF: Specifying target device failed with error "
+				<< "code " << errno << ". Error description "
+				<< strerror(errno) << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}

linux/i2c/I2cComIF.h

@@ -0,0 +1,59 @@
+#ifndef BSP_Q7S_COMIF_I2COMIF_H_
+#define BSP_Q7S_COMIF_I2COMIF_H_
+
+#include "I2cCookie.h"
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+
+#include <unordered_map>
+#include <vector>
+
+/**
+ * @brief 	This is the communication interface for i2c devices connected
+ * 			to a system running a linux OS.
+ *
+ * @author 	J. Meier
+ */
+class I2cComIF: public DeviceCommunicationIF, public SystemObject {
+public:
+	I2cComIF(object_id_t objectId);
+
+	virtual ~I2cComIF();
+
+	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 **buffer,
+			size_t *size) override;
+
+private:
+
+	typedef struct I2cInstance {
+		std::vector<uint8_t> replyBuffer;
+		size_t replyLen;
+	} I2cInstance_t;
+
+	using I2cDeviceMap = std::unordered_map<address_t, I2cInstance_t>;
+	using I2cDeviceMapIter = I2cDeviceMap::iterator;
+
+	/* In this map all i2c devices will be registered with their address and
+	 * the appropriate file descriptor will be stored */
+	I2cDeviceMap i2cDeviceMap;
+	I2cDeviceMapIter i2cDeviceMapIter;
+
+	/**
+	 * @brief	This function opens an i2c device and binds the opened file
+	 * 			to a specific i2c address.
+	 * @param deviceFile	The name of the device file. E.g. i2c-0
+	 * @param i2cAddress	The address of the i2c slave device.
+	 * @param fileDescriptor	Pointer to device descriptor.
+	 * @return	RETURN_OK if successful, otherwise RETURN_FAILED.
+	 */
+	ReturnValue_t openDevice(std::string deviceFile,
+			address_t i2cAddress, int* fileDescriptor);
+};
+
+#endif /* BSP_Q7S_COMIF_I2COMIF_H_ */

linux/i2c/I2cCookie.cpp

@@ -0,0 +1,21 @@
+#include "I2cCookie.h"
+
+I2cCookie::I2cCookie(address_t i2cAddress_, size_t maxReplyLen_,
+		std::string deviceFile_) :
+		i2cAddress(i2cAddress_), maxReplyLen(maxReplyLen_), deviceFile(
+				deviceFile_) {
+}
+
+address_t I2cCookie::getAddress() const {
+	return i2cAddress;
+}
+
+size_t I2cCookie::getMaxReplyLen() const {
+	return maxReplyLen;
+}
+
+std::string I2cCookie::getDeviceFile() const {
+	return deviceFile;
+}
+
+I2cCookie::~I2cCookie() {}

linux/i2c/I2cCookie.h

@@ -0,0 +1,37 @@
+#ifndef SAM9G20_COMIF_COOKIES_I2C_COOKIE_H_
+#define SAM9G20_COMIF_COOKIES_I2C_COOKIE_H_
+
+#include <fsfw/devicehandlers/CookieIF.h>
+#include <string>
+
+/**
+ * @brief   Cookie for the i2cDeviceComIF.
+ *
+ * @author 	J. Meier
+ */
+class I2cCookie: public CookieIF {
+public:
+
+	/**
+	 * @brief	Constructor for the I2C cookie.
+	 * @param i2cAddress_	The i2c address of the target device.
+	 * @param maxReplyLen	The maximum expected length of a reply from the
+	 * 						target device.
+	 */
+	I2cCookie(address_t i2cAddress_, size_t maxReplyLen_,
+			std::string deviceFile_);
+
+	virtual ~I2cCookie();
+
+	address_t getAddress() const;
+	size_t getMaxReplyLen() const;
+	std::string getDeviceFile() const;
+
+private:
+
+	address_t i2cAddress = 0;
+	size_t maxReplyLen = 0;
+	std::string deviceFile;
+};
+
+#endif