move HAL and tests folder

src/fsfw_hal/linux/i2c/CMakeLists.txt

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

src/fsfw_hal/linux/i2c/I2cComIF.cpp

@@ -0,0 +1,237 @@
+#include "I2cComIF.h"
+
+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface.h"
+#include "fsfw_hal/linux/UnixFileGuard.h"
+#include "fsfw_hal/linux/utility.h"
+
+#if FSFW_HAL_I2C_WIRETAPPING == 1
+#include "fsfw/globalfunctions/arrayprinter.h"
+#endif
+
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/i2c-dev.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+#include <cstring>
+
+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) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::initializeInterface: Invalid cookie!" << std::endl;
+#endif
+    return NULLPOINTER;
+  }
+  I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  if (i2cCookie == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::initializeInterface: Invalid I2C cookie!" << std::endl;
+#endif
+    return NULLPOINTER;
+  }
+
+  i2cAddress = i2cCookie->getAddress();
+
+  i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+  if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+    size_t maxReplyLen = i2cCookie->getMaxReplyLen();
+    I2cInstance i2cInstance = {std::vector<uint8_t>(maxReplyLen), 0};
+    auto statusPair = i2cDeviceMap.emplace(i2cAddress, i2cInstance);
+    if (not statusPair.second) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "I2cComIF::initializeInterface: Failed to insert device with address "
+                 << i2cAddress << "to I2C device "
+                 << "map" << std::endl;
+#endif
+      return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::error << "I2cComIF::initializeInterface: Device with address " << i2cAddress
+             << "already in use" << std::endl;
+#endif
+  return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) {
+  ReturnValue_t result;
+  int fd;
+  std::string deviceFile;
+
+  if (sendData == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::sendMessage: Send Data is nullptr" << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+
+  if (sendLen == 0) {
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  if (i2cCookie == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::sendMessage: Invalid I2C Cookie!" << std::endl;
+#endif
+    return NULLPOINTER;
+  }
+
+  address_t i2cAddress = i2cCookie->getAddress();
+  i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+  if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::sendMessage: i2cAddress of Cookie not "
+               << "registered in i2cDeviceMap" << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+
+  deviceFile = i2cCookie->getDeviceFile();
+  UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::sendMessage");
+  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
+    return fileHelper.getOpenResult();
+  }
+  result = openDevice(deviceFile, i2cAddress, &fd);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+
+  if (write(fd, sendData, sendLen) != static_cast<int>(sendLen)) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::sendMessage: Failed to send data to I2C "
+                  "device with error code "
+               << errno << ". Error description: " << strerror(errno) << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+
+#if FSFW_HAL_I2C_WIRETAPPING == 1
+  sif::info << "Sent I2C data to bus " << deviceFile << ":" << std::endl;
+  arrayprinter::print(sendData, sendLen);
+#endif
+  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) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::requestReceiveMessage: Invalid I2C Cookie!" << std::endl;
+#endif
+    i2cDeviceMapIter->second.replyLen = 0;
+    return NULLPOINTER;
+  }
+
+  address_t i2cAddress = i2cCookie->getAddress();
+  i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+  if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::requestReceiveMessage: i2cAddress of Cookie not "
+               << "registered in i2cDeviceMap" << std::endl;
+#endif
+    i2cDeviceMapIter->second.replyLen = 0;
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+
+  deviceFile = i2cCookie->getDeviceFile();
+  UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::requestReceiveMessage");
+  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
+    return fileHelper.getOpenResult();
+  }
+  result = openDevice(deviceFile, i2cAddress, &fd);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    i2cDeviceMapIter->second.replyLen = 0;
+    return result;
+  }
+
+  uint8_t* replyBuffer = i2cDeviceMapIter->second.replyBuffer.data();
+
+  int readLen = read(fd, replyBuffer, requestLen);
+  if (readLen != static_cast<int>(requestLen)) {
+#if FSFW_VERBOSE_LEVEL >= 1 and FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::requestReceiveMessage: Reading from I2C "
+               << "device failed with error code " << errno << ". Description"
+               << " of error: " << strerror(errno) << std::endl;
+    sif::error << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from " << requestLen
+               << " bytes" << std::endl;
+#endif
+    i2cDeviceMapIter->second.replyLen = 0;
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "I2cComIF::requestReceiveMessage: Read " << readLen << " of " << requestLen
+               << " bytes" << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+
+#if FSFW_HAL_I2C_WIRETAPPING == 1
+  sif::info << "I2C read bytes from bus " << deviceFile << ":" << std::endl;
+  arrayprinter::print(replyBuffer, requestLen);
+#endif
+
+  i2cDeviceMapIter->second.replyLen = requestLen;
+  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) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::readReceivedMessage: Invalid I2C Cookie!" << std::endl;
+#endif
+    return NULLPOINTER;
+  }
+
+  address_t i2cAddress = i2cCookie->getAddress();
+  i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+  if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::readReceivedMessage: i2cAddress of Cookie not "
+               << "found in i2cDeviceMap" << std::endl;
+#endif
+    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) {
+  if (ioctl(*fileDescriptor, I2C_SLAVE, i2cAddress) < 0) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "I2cComIF: Specifying target device failed with error code " << errno << "."
+                 << std::endl;
+    sif::warning << "Error description " << strerror(errno) << std::endl;
+#else
+    sif::printWarning("I2cComIF: Specifying target device failed with error code %d.\n");
+    sif::printWarning("Error description: %s\n", strerror(errno));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}

src/fsfw_hal/linux/i2c/I2cComIF.h

@@ -0,0 +1,57 @@
+#ifndef LINUX_I2C_I2COMIF_H_
+#define LINUX_I2C_I2COMIF_H_
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+
+#include <unordered_map>
+#include <vector>
+
+#include "I2cCookie.h"
+
+/**
+ * @brief 	This is the communication interface for I2C devices connected
+ * 			to a system running a Linux OS.
+ *
+ * @note    The Xilinx Linux kernel might not support to read more than 255 bytes at once.
+ *
+ * @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:
+  struct I2cInstance {
+    std::vector<uint8_t> replyBuffer;
+    size_t replyLen;
+  };
+
+  using I2cDeviceMap = std::unordered_map<address_t, I2cInstance>;
+  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 /* LINUX_I2C_I2COMIF_H_ */

src/fsfw_hal/linux/i2c/I2cCookie.cpp

@@ -0,0 +1,12 @@
+#include "fsfw_hal/linux/i2c/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() {}

src/fsfw_hal/linux/i2c/I2cCookie.h

@@ -0,0 +1,36 @@
+#ifndef LINUX_I2C_I2CCOOKIE_H_
+#define LINUX_I2C_I2CCOOKIE_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.
+   * @param devicFile_    The device file specifying the i2c interface to use. E.g. "/dev/i2c-0".
+   */
+  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 /* LINUX_I2C_I2CCOOKIE_H_ */