moved old loggers to archive

misc/archive/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_ */

misc/archive/ServiceInterfaceBuffer.cpp

@@ -0,0 +1,257 @@
+#include "fsfw/serviceinterface/ServiceInterfaceBuffer.h"
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+
+#include <inttypes.h>
+
+#include <cstring>
+
+#include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
+#include "fsfw/timemanager/Clock.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) {
+  Clock::TimeOfDay_t loggerTime;
+  Clock::getDateAndTime(&loggerTime);
+  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 | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
+              this->logMessage.c_str(), sif::ANSI_COLOR_RESET, loggerTime.hour, loggerTime.minute,
+              loggerTime.second, loggerTime.usecond / 1000);
+  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 */

misc/archive/ServiceInterfaceBuffer.h

@@ -0,0 +1,161 @@
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+
+#include <FSFWConfig.h>
+
+#include "../returnvalues/HasReturnvaluesIF.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_ */

misc/archive/ServiceInterfacePrinter.cpp

@@ -0,0 +1,132 @@
+#include "fsfw/serviceinterface/ServiceInterfacePrinter.h"
+
+#include <cstdarg>
+#include <cstdint>
+
+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
+#include "fsfw/timemanager/Clock.h"
+
+static sif::PrintLevel printLevel = sif::PrintLevel::DEBUG_LEVEL;
+#if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
+static bool consoleInitialized = false;
+#endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
+
+#if FSFW_DISABLE_PRINTOUT == 0
+
+static bool addCrAtEnd = false;
+
+uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
+
+void fsfwPrint(sif::PrintLevel printType, const char *fmt, va_list arg) {
+#if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
+  if (not consoleInitialized) {
+    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+    DWORD dwMode = 0;
+    GetConsoleMode(hOut, &dwMode);
+    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    SetConsoleMode(hOut, dwMode);
+  }
+  consoleInitialized = true;
+#endif
+
+  size_t len = 0;
+  char *bufferPosition = reinterpret_cast<char *>(printBuffer);
+
+  /* Check logger level */
+  if (printType == sif::PrintLevel::NONE or printType > printLevel) {
+    return;
+  }
+
+  /* Log message to terminal */
+
+#if FSFW_COLORED_OUTPUT == 1
+  if (printType == sif::PrintLevel::INFO_LEVEL) {
+    len += sprintf(bufferPosition, sif::ANSI_COLOR_GREEN);
+  } else if (printType == sif::PrintLevel::DEBUG_LEVEL) {
+    len += sprintf(bufferPosition, sif::ANSI_COLOR_CYAN);
+  } else if (printType == sif::PrintLevel::WARNING_LEVEL) {
+    len += sprintf(bufferPosition, sif::ANSI_COLOR_YELLOW);
+  } else if (printType == sif::PrintLevel::ERROR_LEVEL) {
+    len += sprintf(bufferPosition, sif::ANSI_COLOR_RED);
+  }
+#endif
+
+  if (printType == sif::PrintLevel::INFO_LEVEL) {
+    len += sprintf(bufferPosition + len, "INFO");
+  }
+  if (printType == sif::PrintLevel::DEBUG_LEVEL) {
+    len += sprintf(bufferPosition + len, "DEBUG");
+  }
+  if (printType == sif::PrintLevel::WARNING_LEVEL) {
+    len += sprintf(bufferPosition + len, "WARNING");
+  }
+
+  if (printType == sif::PrintLevel::ERROR_LEVEL) {
+    len += sprintf(bufferPosition + len, "ERROR");
+  }
+
+#if FSFW_COLORED_OUTPUT == 1
+  len += sprintf(bufferPosition + len, sif::ANSI_COLOR_RESET);
+#endif
+
+  Clock::TimeOfDay_t now;
+  Clock::getDateAndTime(&now);
+  /*
+   * Log current time to terminal if desired.
+   */
+  len += sprintf(bufferPosition + len, " | %lu:%02lu:%02lu.%03lu | ", (unsigned long)now.hour,
+                 (unsigned long)now.minute, (unsigned long)now.second,
+                 (unsigned long)now.usecond / 1000);
+
+  len += vsnprintf(bufferPosition + len, sizeof(printBuffer) - len, fmt, arg);
+
+  if (addCrAtEnd) {
+    len += sprintf(bufferPosition + len, "\r");
+  }
+
+  printf("%s", printBuffer);
+}
+
+void sif::printInfo(const char *fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+  fsfwPrint(sif::PrintLevel::INFO_LEVEL, fmt, args);
+  va_end(args);
+}
+
+void sif::printWarning(const char *fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+  fsfwPrint(sif::PrintLevel::WARNING_LEVEL, fmt, args);
+  va_end(args);
+}
+
+void sif::printDebug(const char *fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+  fsfwPrint(sif::PrintLevel::DEBUG_LEVEL, fmt, args);
+  va_end(args);
+}
+
+void sif::setToAddCrAtEnd(bool addCrAtEnd_) { addCrAtEnd = addCrAtEnd_; }
+
+void sif::printError(const char *fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+  fsfwPrint(sif::PrintLevel::ERROR_LEVEL, fmt, args);
+  va_end(args);
+}
+
+#else
+
+void sif::printInfo(const char *fmt, ...) {}
+void sif::printWarning(const char *fmt, ...) {}
+void sif::printDebug(const char *fmt, ...) {}
+void sif::printError(const char *fmt, ...) {}
+
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
+
+void sif::setPrintLevel(PrintLevel printLevel_) { printLevel = printLevel_; }
+
+sif::PrintLevel sif::getPrintLevel() { return printLevel; }

misc/archive/ServiceInterfacePrinter.h

@@ -0,0 +1,56 @@
+#ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACEPRINTER
+#define FSFW_SERVICEINTERFACE_SERVICEINTERFACEPRINTER
+
+#include "fsfw/FSFW.h"
+
+#if FSFW_DISABLE_PRINTOUT == 0
+#include <cstdio>
+#endif
+
+//! https://stackoverflow.com/questions/111928/is-there-a-printf-converter-to-print-in-binary-format
+//! Can be used to print out binary numbers in human-readable format.
+//! Example usage:
+//! sif::printInfo("Status register: " BYTE_TO_BINARY_PATTERN "\n",BYTE_TO_BINARY(0x1f));
+#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
+#define BYTE_TO_BINARY(byte)                                                           \
+  (byte & 0x80 ? '1' : '0'), (byte & 0x40 ? '1' : '0'), (byte & 0x20 ? '1' : '0'),     \
+      (byte & 0x10 ? '1' : '0'), (byte & 0x08 ? '1' : '0'), (byte & 0x04 ? '1' : '0'), \
+      (byte & 0x02 ? '1' : '0'), (byte & 0x01 ? '1' : '0')
+
+namespace sif {
+
+enum PrintLevel {
+  NONE = 0,
+  //! Strange error when using just ERROR..
+  ERROR_LEVEL = 1,
+  WARNING_LEVEL = 2,
+  INFO_LEVEL = 3,
+  DEBUG_LEVEL = 4
+};
+
+/**
+ * Set the print level. All print types with a smaller level will be printed
+ * as well. For example, set to PrintLevel::WARNING to only enable error
+ * and warning output.
+ * @param printLevel
+ */
+void setPrintLevel(PrintLevel printLevel);
+PrintLevel getPrintLevel();
+
+void setToAddCrAtEnd(bool addCrAtEnd_);
+
+/**
+ * These functions can be used like the C stdio printf and forward the
+ * supplied formatted string arguments to a printf function.
+ * They prepend the string with a color (if enabled), a log preamble and
+ * a timestamp.
+ * @param fmt Formatted string
+ */
+void printInfo(const char* fmt, ...);
+void printWarning(const char* fmt, ...);
+void printDebug(const char* fmt, ...);
+void printError(const char* fmt, ...);
+
+}  // namespace sif
+
+#endif /* FSFW_SERVICEINTERFACE_SERVICEINTERFACEPRINTER */

misc/archive/ServiceInterfaceStream.cpp

@@ -0,0 +1,21 @@
+#include "fsfw/serviceinterface/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

misc/archive/ServiceInterfaceStream.h

@@ -0,0 +1,68 @@
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+
+#include <FSFWConfig.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_ */

misc/archive/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_ */