updated OBSW code

unittest/rebootLogic/src/fsfw/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(serviceinterface)

unittest/rebootLogic/src/fsfw/FSFW.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <cstddef>
+
+#define FSFW_CPP_OSTREAM_ENABLED 1
+
+namespace fsfwconfig {
+static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 256;
+}

unittest/rebootLogic/src/fsfw/serviceinterface/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(reboot-logic PRIVATE
+  ServiceInterfaceStream.cpp
+  ServiceInterfaceBuffer.cpp
+)

unittest/rebootLogic/src/fsfw/serviceinterface/ServiceInterface.h

@@ -0,0 +1,13 @@
+#ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
+#define FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
+
+#include "fsfw/FSFW.h"
+#include "serviceInterfaceDefintions.h"
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+#include "ServiceInterfaceStream.h"
+#else
+#include "ServiceInterfacePrinter.h"
+#endif
+
+#endif /* FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_ */

unittest/rebootLogic/src/fsfw/serviceinterface/ServiceInterfaceBuffer.cpp

@@ -0,0 +1,252 @@
+#include "ServiceInterfaceBuffer.h"
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+
+#include <inttypes.h>
+
+#include <cstring>
+
+#include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
+
+#if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
+#include "Windows.h"
+#endif
+
+// to be implemented by bsp
+extern "C" void printChar(const char*, bool errStream);
+
+#ifndef UT699
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
+                                               bool buffered, bool errStream, uint16_t port)
+    : isActive(true),
+      logMessage(setMessage),
+      addCrToPreamble(addCrToPreamble),
+      buffered(buffered),
+      errStream(errStream) {
+  if (buffered) {
+    // Set pointers if the stream is buffered.
+    setp(buf, buf + BUF_SIZE);
+  }
+
+#if FSFW_COLORED_OUTPUT == 1
+  if (setMessage.find("DEBUG") != std::string::npos) {
+    colorPrefix = sif::ANSI_COLOR_CYAN;
+  } else if (setMessage.find("INFO") != std::string::npos) {
+    colorPrefix = sif::ANSI_COLOR_GREEN;
+  } else if (setMessage.find("WARNING") != std::string::npos) {
+    colorPrefix = sif::ANSI_COLOR_MAGENTA;
+  } else if (setMessage.find("ERROR") != std::string::npos) {
+    colorPrefix = sif::ANSI_COLOR_RED;
+  } else {
+    colorPrefix = sif::ANSI_COLOR_RESET;
+  }
+
+#ifdef WIN32
+  HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+  DWORD dwMode = 0;
+  GetConsoleMode(hOut, &dwMode);
+  dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+  SetConsoleMode(hOut, dwMode);
+#endif
+
+#endif
+
+  preamble.reserve(MAX_PREAMBLE_SIZE);
+  preamble.resize(MAX_PREAMBLE_SIZE);
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+  char array[BUF_SIZE];
+  uint32_t length = end - begin;
+  if (length > sizeof(array)) {
+    length = sizeof(array);
+  }
+  memcpy(array, begin, length);
+
+  for (; begin != end; begin++) {
+    if (errStream) {
+      printChar(begin, true);
+    } else {
+      printChar(begin, false);
+    }
+  }
+}
+
+#endif
+
+int ServiceInterfaceBuffer::overflow(int c) {
+  if (not buffered and this->isActive) {
+    if (c != Traits::eof()) {
+      if (errStream) {
+        printChar(reinterpret_cast<const char*>(&c), true);
+      } else {
+        printChar(reinterpret_cast<const char*>(&c), false);
+      }
+    }
+    return 0;
+  }
+  // Handle output
+  putChars(pbase(), pptr());
+  if (c != Traits::eof()) {
+    char c2 = c;
+    // Handle the one character that didn't fit to buffer
+    putChars(&c2, &c2 + 1);
+  }
+  // This tells that buffer is empty again
+  setp(buf, buf + BUF_SIZE - 1);
+  // I'm not sure about this return value!
+  return 0;
+}
+
+int ServiceInterfaceBuffer::sync(void) {
+  if (not this->isActive and not buffered) {
+    if (not buffered) {
+      setp(buf, buf + BUF_SIZE - 1);
+    }
+    return 0;
+  }
+  if (not buffered) {
+    return 0;
+  }
+
+  size_t preambleSize = 0;
+  std::string* preamble = getPreamble(&preambleSize);
+  // Write logMessage and time
+  this->putChars(preamble->data(), preamble->data() + preambleSize);
+  // Handle output
+  this->putChars(pbase(), pptr());
+  // This tells that buffer is empty again
+  setp(buf, buf + BUF_SIZE - 1);
+  return 0;
+}
+
+bool ServiceInterfaceBuffer::isBuffered() const { return buffered; }
+
+std::string* ServiceInterfaceBuffer::getPreamble(size_t* preambleSize) {
+  size_t currentSize = 0;
+  char* parsePosition = &preamble[0];
+  if (addCrToPreamble) {
+    preamble[0] = '\r';
+    currentSize += 1;
+    parsePosition += 1;
+  }
+
+#if FSFW_COLORED_OUTPUT == 1
+  currentSize += sprintf(parsePosition, "%s", colorPrefix.c_str());
+  parsePosition += colorPrefix.size();
+#endif
+
+  int32_t charCount =
+      sprintf(parsePosition, "%s%s | ", this->logMessage.c_str(), sif::ANSI_COLOR_RESET);
+  if (charCount < 0) {
+    printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
+    return &preamble;
+  }
+  if (charCount > MAX_PREAMBLE_SIZE) {
+    printf(
+        "ServiceInterfaceBuffer: Char count too large for maximum "
+        "preamble size");
+    return &preamble;
+  }
+  currentSize += charCount;
+  if (preambleSize != nullptr) {
+    *preambleSize = currentSize;
+  }
+  return &preamble;
+}
+
+bool ServiceInterfaceBuffer::crAdditionEnabled() const { return addCrToPreamble; }
+
+#if FSFW_COLORED_OUTPUT == 1
+void ServiceInterfaceBuffer::setAsciiColorPrefix(std::string colorPrefix) {
+  this->colorPrefix = colorPrefix;
+}
+#endif
+
+#ifdef UT699
+#include "../osal/rtems/Interrupt.h"
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
+  this->log_message = set_message;
+  this->isActive = true;
+  setp(buf, buf + BUF_SIZE);
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+  char array[BUF_SIZE];
+  uint32_t length = end - begin;
+  if (length > sizeof(array)) {
+    length = sizeof(array);
+  }
+  memcpy(array, begin, length);
+
+  if (!Interrupt::isInterruptInProgress()) {
+    std::cout << array;
+  } else {
+    // Uncomment the following line if you need ISR debug output.
+    //		printk(array);
+  }
+}
+#endif  // UT699
+
+#ifdef ML505
+#include <bsp_flp/network/networkconfig.h>
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port)
+    : isActive(true),
+      log_message(set_message),
+      udpSocket(0),
+      remoteAddressLength(sizeof(remoteAddress)) {
+  setp(buf, buf + BUF_SIZE);
+  memset((uint8_t*)&remoteAddress, 0, sizeof(remoteAddress));
+  remoteAddress.sin_family = AF_INET;
+  remoteAddress.sin_port = htons(port);
+  remoteAddress.sin_addr.s_addr = htonl(inet_addr("192.168.250.100"));
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+  char array[BUF_SIZE];
+  uint32_t length = end - begin;
+  if (length > sizeof(array)) {
+    length = sizeof(array);
+  }
+  memcpy(array, begin, length);
+
+  if (udpSocket <= 0) {
+    initSocket();
+  }
+
+  if (udpSocket > 0) {
+    sendto(udpSocket, array, length, 0, (sockaddr*)&remoteAddress, sizeof(remoteAddress));
+  }
+}
+
+void ServiceInterfaceBuffer::initSocket() {
+  sockaddr_in address;
+  memset((uint8_t*)&address, 0, sizeof(address));
+  address.sin_family = AF_INET;
+  address.sin_port = htons(0);
+  address.sin_addr.s_addr = htonl(INADDR_ANY);
+
+  udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
+  if (socket < 0) {
+    printf("Error opening socket!\n");
+    return;
+  }
+  timeval timeout = {0, 20};
+  if (setsockopt(udpSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
+    printf("Error setting SO_RCVTIMEO socket options!\n");
+    return;
+  }
+  if (setsockopt(udpSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) < 0) {
+    printf("Error setting SO_SNDTIMEO socket options!\n");
+    return;
+  }
+  if (bind(udpSocket, (sockaddr*)&address, sizeof(address)) < 0) {
+    printf("Error binding socket!\n");
+  }
+}
+
+#endif  // ML505
+
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */

unittest/rebootLogic/src/fsfw/serviceinterface/ServiceInterfaceBuffer.h

@@ -0,0 +1,159 @@
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+
+#include "fsfw/FSFW.h"
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+
+#ifndef UT699
+
+/**
+ * @brief 	This is the underlying stream buffer which implements the
+ * 			streambuf class and overloads the overflow() and sync() methods
+ * @details
+ * This class is used to modify the output of the stream, for example by adding.
+ * It also calls the char printing function which is implemented in the
+ * board supply package (BSP).
+ */
+class ServiceInterfaceBuffer : public std::streambuf {
+  friend class ServiceInterfaceStream;
+
+ public:
+  static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
+
+  ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble, bool buffered,
+                         bool errStream, uint16_t port);
+
+ protected:
+  bool isActive;
+  //! This is called when buffer becomes full. If
+  //! buffer is not used, then this is called every
+  //! time when characters are put to stream.
+  int overflow(int c = Traits::eof()) override;
+
+  //! This function is called when stream is flushed,
+  //! for example when std::endl is put to stream.
+  int sync(void) override;
+
+  bool isBuffered() const;
+
+ private:
+  //! For additional message information
+  std::string logMessage;
+  std::string preamble;
+
+#if FSFW_COLORED_OUTPUT == 1
+  std::string colorPrefix;
+  void setAsciiColorPrefix(std::string colorPrefix);
+#endif
+
+  // For EOF detection
+  typedef std::char_traits<char> Traits;
+
+  //! This is useful for some terminal programs which do not have
+  //! implicit carriage return with newline characters.
+  bool addCrToPreamble;
+
+  //! Specifies whether the stream operates in buffered or unbuffered mode.
+  bool buffered;
+  //! This specifies to print to stderr and work in unbuffered mode.
+  bool errStream;
+
+  //! Needed for buffered mode.
+  static size_t const BUF_SIZE = fsfwconfig::FSFW_PRINT_BUFFER_SIZE;
+  char buf[BUF_SIZE];
+
+  //! In this function, the characters are parsed.
+  void putChars(char const* begin, char const* end);
+
+  std::string* getPreamble(size_t* preambleSize = nullptr);
+
+  bool crAdditionEnabled() const;
+};
+
+#endif
+
+#ifdef UT699
+class ServiceInterfaceBuffer : public std::basic_streambuf<char, std::char_traits<char> > {
+  friend class ServiceInterfaceStream;
+
+ public:
+  ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+
+ protected:
+  bool isActive;
+  // This is called when buffer becomes full. If
+  // buffer is not used, then this is called every
+  // time when characters are put to stream.
+  virtual int overflow(int c = Traits::eof());
+
+  // This function is called when stream is flushed,
+  // for example when std::endl is put to stream.
+  virtual int sync(void);
+
+ private:
+  // For additional message information
+  std::string log_message;
+  // For EOF detection
+  typedef std::char_traits<char> Traits;
+
+  // Work in buffer mode. It is also possible to work without buffer.
+  static size_t const BUF_SIZE = 128;
+  char buf[BUF_SIZE];
+
+  // In this function, the characters are parsed.
+  void putChars(char const* begin, char const* end);
+};
+#endif  // UT699
+
+#ifdef ML505
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+class ServiceInterfaceBuffer : public std::basic_streambuf<char, std::char_traits<char> > {
+  friend class ServiceInterfaceStream;
+
+ public:
+  ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+
+ protected:
+  bool isActive;
+  // This is called when buffer becomes full. If
+  // buffer is not used, then this is called every
+  // time when characters are put to stream.
+  virtual int overflow(int c = Traits::eof());
+
+  // This function is called when stream is flushed,
+  // for example when std::endl is put to stream.
+  virtual int sync(void);
+
+ private:
+  // For additional message information
+  std::string log_message;
+  // For EOF detection
+  typedef std::char_traits<char> Traits;
+
+  // Work in buffer mode. It is also possible to work without buffer.
+  static size_t const BUF_SIZE = 128;
+  char buf[BUF_SIZE];
+
+  // In this function, the characters are parsed.
+  void putChars(char const* begin, char const* end);
+
+  int udpSocket;
+  sockaddr_in remoteAddress;
+  socklen_t remoteAddressLength;
+  void initSocket();
+};
+#endif  // ML505
+
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
+#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */

unittest/rebootLogic/src/fsfw/serviceinterface/ServiceInterfaceStream.cpp

@@ -0,0 +1,21 @@
+#include "ServiceInterfaceStream.h"
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+
+ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage, bool addCrToPreamble,
+                                               bool buffered, bool errStream, uint16_t port)
+    : std::ostream(&streambuf), streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
+
+void ServiceInterfaceStream::setActive(bool myActive) { this->streambuf.isActive = myActive; }
+
+std::string* ServiceInterfaceStream::getPreamble() { return streambuf.getPreamble(); }
+
+bool ServiceInterfaceStream::crAdditionEnabled() const { return streambuf.crAdditionEnabled(); }
+
+#if FSFW_COLORED_OUTPUT == 1
+void ServiceInterfaceStream::setAsciiColorPrefix(std::string asciiColorCode) {
+  streambuf.setAsciiColorPrefix(asciiColorCode);
+}
+#endif
+
+#endif

unittest/rebootLogic/src/fsfw/serviceinterface/ServiceInterfaceStream.h

@@ -0,0 +1,68 @@
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+
+#include "fsfw/FSFW.h"
+
+#include "ServiceInterfaceBuffer.h"
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+
+#include <cstdio>
+#include <iostream>
+
+/**
+ * Generic service interface stream which can be used like std::cout or
+ * std::cerr but has additional capability. Add preamble and timestamp
+ * to output. Can be run in buffered or unbuffered mode.
+ */
+class ServiceInterfaceStream : public std::ostream {
+ public:
+  /**
+   * This constructor is used by specifying the preamble message.
+   * Optionally, the output can be directed to stderr and a CR character
+   * can be prepended to the preamble.
+   * @param setMessage message of preamble.
+   * @param addCrToPreamble Useful for applications like Puttty.
+   * @param buffered specify whether to use buffered mode.
+   * @param errStream specify which output stream to use (stderr or stdout).
+   */
+  ServiceInterfaceStream(std::string setMessage, bool addCrToPreamble = false, bool buffered = true,
+                         bool errStream = false, uint16_t port = 1234);
+
+  //! An inactive stream will not print anything.
+  void setActive(bool);
+
+  /**
+   * This can be used to retrieve the preamble in case it should be printed in
+   * the unbuffered mode.
+   * @return Preamle consisting of log message and timestamp.
+   */
+  std::string* getPreamble();
+
+  /**
+   * Can be used to determine if the stream was configured to add CR characters in addition
+   * to newline characters.
+   * @return
+   */
+  bool crAdditionEnabled() const;
+
+#if FSFW_COLORED_OUTPUT == 1
+  void setAsciiColorPrefix(std::string asciiColorCode);
+#endif
+
+ protected:
+  ServiceInterfaceBuffer streambuf;
+};
+
+// Forward declaration of interface streams. These should be instantiated in
+// main. They can then be used like std::cout or std::cerr.
+namespace sif {
+extern ServiceInterfaceStream debug;
+extern ServiceInterfaceStream info;
+extern ServiceInterfaceStream warning;
+extern ServiceInterfaceStream error;
+}  // namespace sif
+
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
+#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

unittest/rebootLogic/src/fsfw/serviceinterface/serviceInterfaceDefintions.h

@@ -0,0 +1,18 @@
+#ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
+#define FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
+
+namespace sif {
+
+enum class OutputTypes { OUT_INFO, OUT_DEBUG, OUT_WARNING, OUT_ERROR };
+
+static const char* const ANSI_COLOR_RED = "\x1b[31m";
+static const char* const ANSI_COLOR_GREEN = "\x1b[32m";
+static const char* const ANSI_COLOR_YELLOW = "\x1b[33m";
+static const char* const ANSI_COLOR_BLUE = "\x1b[34m";
+static const char* const ANSI_COLOR_MAGENTA = "\x1b[35m";
+static const char* const ANSI_COLOR_CYAN = "\x1b[36m";
+static const char* const ANSI_COLOR_RESET = "\x1b[0m";
+
+}  // namespace sif
+
+#endif /* FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_ */