squashed EIVE software

bsp_linux_board/CMakeLists.txt

@@ -0,0 +1,6 @@
+target_sources(${OBSW_NAME} PUBLIC InitMission.cpp main.cpp gpioInit.cpp
+                                   ObjectFactory.cpp)
+
+add_subdirectory(boardconfig)
+add_subdirectory(boardtest)
+add_subdirectory(fsfwconfig)

bsp_linux_board/Dockerfile

@@ -0,0 +1,37 @@
+FROM ubuntu:latest
+# FROM alpine:latest
+
+RUN apt-get update && apt-get install -y curl wget cmake g++
+
+# Raspberry Pi rootfs
+RUN mkdir -p /usr/rootfs; \
+    curl https://eive-cloud.irs.uni-stuttgart.de/index.php/s/kJe3nCnGPRGKFCz/download/rpi-rootfs.tar.gz /usr/rootfs \
+    | tar xvz -C /usr/rootfs
+# Raspberry Pi toolchain
+RUN mkdir -p /opt; \
+    cd /opt; \
+    wget https://github.com/Pro/raspi-toolchain/releases/latest/download/raspi-toolchain.tar.gz; \
+    tar xfz raspi-toolchain.tar.gz --strip-components=1 -C .; \
+    rm -rf raspi-toolchain.tar.gz
+
+# RUN apk add cmake make g++
+
+# Required for cmake build
+ENV RASPBERRY_VERSION="4"
+ENV RASPBIAN_ROOTFS="/usr/rootfs/rootfs"
+ENV PATH=$PATH:"/opt/cross-pi-gcc/bin"
+ENV CROSS_COMPILE="arm-linux-gnueabihf"
+
+WORKDIR /usr/src/app
+COPY . .
+
+RUN set -ex; \
+    rm -rf build-rpi; \
+    mkdir build-rpi; \
+    cd build-rpi; \
+    cmake -DCMAKE_BUILD_TYPE=Release -DOS_FSFW=linux -DTGT_BSP="arm/raspberrypi" ..;
+
+ENTRYPOINT ["cmake", "--build", "build-rpi"]
+CMD ["-j"]
+# CMD ["bash"]
+

bsp_linux_board/InitMission.cpp

@@ -0,0 +1,267 @@
+#include "InitMission.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+#include <fsfw/tasks/PeriodicTaskIF.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <linux/InitMission.h>
+#include <mission/utility/InitMission.h>
+
+#include <iostream>
+
+#include "OBSWConfig.h"
+#include "ObjectFactory.h"
+#include "objects/systemObjectList.h"
+#include "pollingsequence/pollingSequenceFactory.h"
+
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR");
+
+ObjectManagerIF* objectManager = nullptr;
+
+void initmission::initMission() {
+  sif::info << "Building global objects.." << std::endl;
+  /* Instantiate global object manager and also create all objects */
+  ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
+  sif::info << "Initializing all objects.." << std::endl;
+  ObjectManager::instance()->initialize();
+
+  /* This function creates and starts all tasks */
+  initTasks();
+}
+
+void initmission::initTasks() {
+  TaskFactory* factory = TaskFactory::instance();
+  ReturnValue_t result = returnvalue::OK;
+  if (factory == nullptr) {
+    /* Should never happen ! */
+    return;
+  }
+#if OBSW_PRINT_MISSED_DEADLINES == 1
+  void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
+#else
+  void (*missedDeadlineFunc)(void) = nullptr;
+#endif
+
+  /* TMTC Distribution */
+  PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
+      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
+  if (result != returnvalue::OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
+  if (result != returnvalue::OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
+  if (result != returnvalue::OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+
+  /* UDP bridge */
+  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
+      "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
+  if (result != returnvalue::OK) {
+    sif::error << "Add component TMTC Bridge failed" << std::endl;
+  }
+  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
+      "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
+  if (result != returnvalue::OK) {
+    sif::error << "Add component TMTC Polling failed" << std::endl;
+  }
+
+#if OBSW_ADD_SCEX_DEVICE == 1
+  PeriodicTaskIF* scexDevHandler;
+  PeriodicTaskIF* scexReaderTask;
+  scheduling::schedulingScex(*factory, scexDevHandler, scexReaderTask);
+#endif
+
+  /* PUS Services */
+  std::vector<PeriodicTaskIF*> pusTasks;
+  createPusTasks(*factory, missedDeadlineFunc, pusTasks);
+
+  std::vector<PeriodicTaskIF*> pstTasks;
+  createPstTasks(*factory, missedDeadlineFunc, pstTasks);
+#if OBSW_ADD_TEST_CODE == 1
+  std::vector<PeriodicTaskIF*> testTasks;
+  createTestTasks(*factory, missedDeadlineFunc, pstTasks);
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+
+  auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
+    for (const auto& task : taskVector) {
+      if (task != nullptr) {
+        task->startTask();
+      } else {
+        sif::error << "Task in vector " << name << " is invalid!" << std::endl;
+      }
+    }
+  };
+
+  sif::info << "Starting tasks.." << std::endl;
+  tmTcDistributor->startTask();
+  tmtcBridgeTask->startTask();
+  tmtcPollingTask->startTask();
+
+  taskStarter(pusTasks, "PUS Tasks");
+#if OBSW_ADD_TEST_CODE == 1
+  taskStarter(testTasks, "Test Tasks");
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+  taskStarter(pstTasks, "PST Tasks");
+
+#if OBSW_ADD_SCEX_DEVICE == 1
+  scexDevHandler->startTask();
+  scexReaderTask->startTask();
+#endif
+#if OBSW_ADD_TEST_PST == 1
+  if (startTestPst) {
+    pstTestTask->startTask();
+  }
+#endif /* RPI_TEST_ACS_BOARD == 1 */
+  sif::info << "Tasks started.." << std::endl;
+}
+
+void initmission::createPusTasks(TaskFactory& factory,
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
+  ReturnValue_t result = returnvalue::OK;
+  PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
+      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+  if (result != returnvalue::OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  taskVec.push_back(pusVerification);
+
+  PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
+      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
+  }
+  result = pusEvents->addComponent(objects::EVENT_MANAGER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
+  }
+  taskVec.push_back(pusEvents);
+
+  PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
+      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  }
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
+  }
+  taskVec.push_back(pusHighPrio);
+
+  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
+      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+  }
+  taskVec.push_back(pusMedPrio);
+
+  PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
+      "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
+  result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
+  }
+  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
+  }
+  taskVec.push_back(pusLowPrio);
+}
+
+void initmission::createPstTasks(TaskFactory& factory,
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
+  ReturnValue_t result = returnvalue::OK;
+#if OBSW_ADD_SPI_TEST_CODE == 0
+  FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
+      "SPI_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
+  result = pst::pstSpi(spiPst);
+  if (result != returnvalue::OK) {
+    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::error << "InitMission::createPstTasks: Creating PST failed!" << std::endl;
+    }
+  } else {
+    taskVec.push_back(spiPst);
+  }
+#endif
+}
+
+void initmission::createTestTasks(TaskFactory& factory,
+                                  TaskDeadlineMissedFunction missedDeadlineFunc,
+                                  std::vector<PeriodicTaskIF*>& taskVec) {
+  ReturnValue_t result = returnvalue::OK;
+  PeriodicTaskIF* testTask = factory.createPeriodicTask(
+      "TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = testTask->addComponent(objects::TEST_TASK);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
+  }
+#if OBSW_ADD_SPI_TEST_CODE == 1
+  result = testTask->addComponent(objects::SPI_TEST);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
+  }
+#endif /* RPI_ADD_SPI_TEST == 1 */
+#if RPI_ADD_GPIO_TEST == 1
+  result = testTask->addComponent(objects::LIBGPIOD_TEST);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
+  }
+#endif /* RPI_ADD_GPIO_TEST == 1 */
+#if OBSW_ADD_UART_TEST_CODE == 1
+  result = testTask->addComponent(objects::UART_TEST);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
+  }
+  PeriodicTaskIF* scexReaderTask = factory.createPeriodicTask(
+      "SCEX_UART_READER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = scexReaderTask->addComponent(objects::SCEX_UART_READER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("SCEX_UART_READER", objects::SCEX_UART_READER);
+  }
+  taskVec.push_back(scexReaderTask);
+#endif /* RPI_ADD_GPIO_TEST == 1 */
+  taskVec.push_back(testTask);
+
+  bool startTestPst = true;
+  static_cast<void>(startTestPst);
+#if OBSW_ADD_TEST_PST == 1
+  FixedTimeslotTaskIF* pstTestTask = factory->createFixedTimeslotTask(
+      "TEST_PST", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
+  result = pst::pstTest(pstTestTask);
+  if (result != returnvalue::OK) {
+    sif::info << "initmission::initTasks: ACS PST empty or invalid" << std::endl;
+    startTestPst = false;
+  }
+#endif /* RPI_TEST_ACS_BOARD == 1 */
+}

bsp_linux_board/InitMission.h

@@ -0,0 +1,23 @@
+#ifndef BSP_LINUX_INITMISSION_H_
+#define BSP_LINUX_INITMISSION_H_
+
+#include <vector>
+
+#include "fsfw/tasks/definitions.h"
+
+class PeriodicTaskIF;
+class TaskFactory;
+
+namespace initmission {
+void initMission();
+void initTasks();
+
+void createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                    std::vector<PeriodicTaskIF*>& taskVec);
+void createTestTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                     std::vector<PeriodicTaskIF*>& taskVec);
+void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                    std::vector<PeriodicTaskIF*>& taskVec);
+};  // namespace initmission
+
+#endif /* BSP_LINUX_INITMISSION_H_ */

bsp_linux_board/OBSWConfig.h.in

@@ -0,0 +1,129 @@
+/**
+ * @brief   This file can be used to add preprocessor define for conditional
+ *          code inclusion exclusion or various other project constants and
+ *          properties in one place.
+ */
+#ifndef FSFWCONFIG_OBSWCONFIG_H_
+#define FSFWCONFIG_OBSWCONFIG_H_
+
+#include "commonConfig.h"
+#include "OBSWVersion.h"
+     
+/*******************************************************************/
+/** All of the following flags should be enabled for mission code  */
+/*******************************************************************/
+
+#define OBSW_ENABLE_TIMERS                          1
+#define OBSW_ADD_STAR_TRACKER                       0
+#define OBSW_ADD_PLOC_SUPERVISOR                    0
+#define OBSW_ADD_PLOC_MPSOC                         0
+#define OBSW_ADD_SUN_SENSORS                        0
+#define OBSW_ADD_MGT                                0
+#define OBSW_ADD_ACS_BOARD                          0
+#define OBSW_ADD_ACS_HANDLERS                       0
+#define OBSW_ADD_GPS_0                              0
+#define OBSW_ADD_GPS_1                              0
+#define OBSW_ADD_RW                                 0
+#define OBSW_ADD_BPX_BATTERY_HANDLER                0
+#define OBSW_ADD_RTD_DEVICES                        0
+#define OBSW_ADD_PL_PCDU                            0
+#define OBSW_ADD_TMP_DEVICES                        0
+#define OBSW_ADD_SCEX_DEVICE                        1
+#define OBSW_ADD_RAD_SENSORS                        0
+#define OBSW_ADD_SYRLINKS                           0
+#define OBSW_STAR_TRACKER_GROUND_CONFIG             1
+
+// This is a really tricky switch.. It initializes the PCDU switches to their default states
+// at powerup. I think it would be better
+// to leave it off for now. It makes testing a lot more difficult and it might mess with
+// something the operators might want to do by giving the software too much intelligence
+// at the wrong place. The system component might command all the Switches accordingly anyway
+#define OBSW_INITIALIZE_SWITCHES                    0
+#define OBSW_ENABLE_PERIODIC_HK                     0
+
+/*******************************************************************/
+/** All of the following flags should be disabled for mission code */
+/*******************************************************************/
+
+// Can be used to switch device to NORMAL mode immediately
+#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
+#define OBSW_PRINT_MISSED_DEADLINES                 1
+
+#define OBSW_SYRLINKS_SIMULATED                     1
+#define OBSW_ADD_TEST_CODE                          0
+#define OBSW_ADD_TEST_TASK                          0
+#define OBSW_ADD_TEST_PST                           0
+// If this is enabled, all other SPI code should be disabled
+#define OBSW_ADD_SPI_TEST_CODE                      0
+// If this is enabled, all other I2C code should be disabled
+#define OBSW_ADD_I2C_TEST_CODE                      0
+#define OBSW_ADD_UART_TEST_CODE                     0
+
+#define OBSW_TEST_ACS                               0
+#define OBSW_DEBUG_ACS                              0
+#define OBSW_TEST_SUS                               0
+#define OBSW_DEBUG_SUS                              0
+#define OBSW_TEST_RTD                               0
+#define OBSW_DEBUG_RTD                              0
+#define OBSW_TEST_RAD_SENSOR                        0
+#define OBSW_DEBUG_RAD_SENSOR                       0
+#define OBSW_TEST_PL_PCDU                           0
+#define OBSW_DEBUG_PL_PCDU                          0
+#define OBSW_TEST_BPX_BATT                          0
+#define OBSW_DEBUG_BPX_BATT                         0
+#define OBSW_TEST_IMTQ                              0
+#define OBSW_DEBUG_IMTQ                             0
+#define OBSW_TEST_RW                                0
+#define OBSW_DEBUG_RW                               0
+
+#define OBSW_TEST_LIBGPIOD                          0
+#define OBSW_TEST_PLOC_HANDLER                      0
+#define OBSW_TEST_CCSDS_BRIDGE                      0
+#define OBSW_TEST_CCSDS_PTME                        0
+#define OBSW_TEST_TE7020_HEATER                     0
+#define OBSW_TEST_GPIO_OPEN_BY_LABEL                0
+#define OBSW_TEST_GPIO_OPEN_BY_LINE_NAME            0
+#define OBSW_DEBUG_P60DOCK                          0
+
+#define OBSW_PRINT_CORE_HK                          0
+#define OBSW_DEBUG_PDU1                             0
+#define OBSW_DEBUG_PDU2                             0
+#define OBSW_DEBUG_GPS                              0
+#define OBSW_DEBUG_ACU                              0
+#define OBSW_DEBUG_SYRLINKS                         0
+
+#define OBSW_DEBUG_PDEC_HANDLER                     0
+#define OBSW_DEBUG_PLOC_SUPERVISOR                  0
+#define OBSW_DEBUG_PLOC_MPSOC                       0
+#define OBSW_DEBUG_STARTRACKER                      0
+#define OBSW_TCP_SERVER_WIRETAPPING                 0
+
+/*******************************************************************/
+/** CMake Defines                                                  */
+/*******************************************************************/
+#cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER
+
+#define OBSW_ADD_CCSDS_IP_CORES                     0
+// Set to 1 if all telemetry should be sent to the PTME IP Core
+#define OBSW_TM_TO_PTME                             0
+// Set to 1 if telecommands are received via the PDEC IP Core
+#define OBSW_TC_FROM_PDEC                           0
+
+#cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@
+#cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@
+
+#ifdef RASPBERRY_PI
+#include "rpiConfig.h"
+#elif defined(XIPHOS_Q7S)
+#include "q7sConfig.h"
+#endif
+
+#ifdef __cplusplus
+
+#include "objects/systemObjectList.h"
+#include "events/subsystemIdRanges.h"
+#include "returnvalues/classIds.h"
+
+#endif
+
+#endif /* FSFWCONFIG_OBSWCONFIG_H_ */

bsp_linux_board/ObjectFactory.cpp

@@ -0,0 +1,248 @@
+#include "ObjectFactory.h"
+
+#include <bsp_linux_board/RPiSdCardManager.h>
+#include <linux/devices/ScexUartReader.h>
+
+#include "OBSWConfig.h"
+#include "devConf.h"
+#include "devices/addresses.h"
+#include "devices/gpioIds.h"
+#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/power/DummyPowerSwitcher.h"
+#include "fsfw/tasks/TaskFactory.h"
+#include "fsfw/tmtcpacket/pus/tm.h"
+#include "fsfw/tmtcservices/CommandingServiceBase.h"
+#include "fsfw/tmtcservices/PusServiceBase.h"
+#include "gpioInit.h"
+#include "linux/ObjectFactory.h"
+#include "linux/boardtest/LibgpiodTest.h"
+#include "linux/boardtest/SpiTestClass.h"
+#include "linux/boardtest/UartTestClass.h"
+#include "mission/core/GenericFactory.h"
+#include "mission/devices/GPSHyperionHandler.h"
+#include "mission/devices/GyroADIS1650XHandler.h"
+#include "mission/tmtc/TmFunnel.h"
+#include "objects/systemObjectList.h"
+#include "tmtc/pusIds.h"
+
+/* UDP server includes */
+#if OBSW_USE_TMTC_TCP_BRIDGE == 1
+#include <fsfw/src/fsfw/osal/common/TcpTmTcBridge.h>
+#include <fsfw/src/fsfw/osal/common/TcpTmTcServer.h>
+#else
+#include "fsfw/osal/common/UdpTcPollingTask.h"
+#include "fsfw/osal/common/UdpTmTcBridge.h"
+#endif
+
+#include <fsfw_hal/linux/serial/SerialComIF.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
+
+#include "fsfw_hal/common/gpio/GpioCookie.h"
+#include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
+#include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
+#include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
+#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
+#include "fsfw_hal/linux/rpi/GpioRPi.h"
+#include "fsfw_hal/linux/spi/SpiComIF.h"
+#include "fsfw_hal/linux/spi/SpiCookie.h"
+
+void Factory::setStaticFrameworkObjectIds() {
+  PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
+  PusServiceBase::PACKET_DESTINATION = objects::TM_FUNNEL;
+
+  CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
+  CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+
+  TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
+  // No storage object for now.
+  TmFunnel::storageDestination = objects::NO_OBJECT;
+}
+
+void ObjectFactory::produce(void* args) {
+  Factory::setStaticFrameworkObjectIds();
+  ObjectFactory::produceGenericObjects();
+
+  GpioIF* gpioIF = new LinuxLibgpioIF(objects::GPIO_IF);
+  GpioCookie* gpioCookie = nullptr;
+  static_cast<void>(gpioCookie);
+
+  SpiComIF* spiComIF = new SpiComIF(objects::SPI_MAIN_COM_IF, spi::DEV, gpioIF);
+  static_cast<void>(spiComIF);
+  auto pwrSwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
+  static_cast<void>(pwrSwitcher);
+
+#if OBSW_ADD_ACS_BOARD == 1 && defined(RASPBERRY_PI)
+  createRpiAcsBoard(gpioIF, spiDev);
+#endif
+
+#if OBSW_ADD_SUN_SENSORS == 1 || OBSW_ADD_RTD_DEVICES == 1
+#ifdef RASPBERRY_PI
+  rpi::gpio::initSpiCsDecoder(gpioIF);
+#endif
+#endif
+
+#if OBSW_ADD_SCEX_DEVICE == 1
+  auto* sdcMan = new DummySdCardManager("/tmp");
+  createScexComponents(uart::DEV, pwrSwitcher, *sdcMan, true, std::nullopt);
+#endif
+
+#if OBSW_ADD_SUN_SENSORS == 1
+  createSunSensorComponents(gpioIF, spiComIF, pwrSwitcher, spi::DEV);
+#endif
+
+#if OBSW_ADD_RTD_DEVICES == 1
+  createRtdComponents(spi::DEV, gpioIF, pwrSwitcher);
+#endif
+
+#if OBSW_ADD_TEST_CODE == 1
+  createTestTasks();
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+}
+
+void ObjectFactory::createRpiAcsBoard(GpioIF* gpioIF, std::string spiDev) {
+  GpioCookie* gpioCookie = new GpioCookie();
+  // TODO: Missing pin for Gyro 2
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_0_LIS3_CS, gpio::MGM_0_BCM_PIN, "MGM_0_LIS3",
+                            gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_1_RM3100_CS, gpio::MGM_1_BCM_PIN,
+                            "MGM_1_RM3100", gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_2_LIS3_CS, gpio::MGM_2_BCM_PIN, "MGM_2_LIS3",
+                            gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_3_RM3100_CS, gpio::MGM_3_BCM_PIN,
+                            "MGM_3_RM3100", gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_0_ADIS_CS, gpio::GYRO_0_BCM_PIN,
+                            "GYRO_0_ADIS", gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_1_L3G_CS, gpio::GYRO_1_BCM_PIN, "GYRO_1_L3G",
+                            gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_2_ADIS_CS, gpio::GYRO_2_BCM_PIN,
+                            "GYRO_2_ADIS", gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_3_L3G_CS, gpio::GYRO_3_BCM_PIN, "GYRO_3_L3G",
+                            gpio::Direction::OUT, gpio::Levels::HIGH);
+  gpioIF->addGpios(gpioCookie);
+  SpiCookie* spiCookie =
+      new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
+                    spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
+  auto mgmLis3Handler =
+      new MgmLIS3MDLHandler(objects::MGM_0_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, 0);
+  mgmLis3Handler->setStartUpImmediately();
+#if OBSW_TEST_ACS == 1
+  mgmLis3Handler->setToGoToNormalMode(true);
+#endif
+
+  spiCookie =
+      new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, RM3100::MAX_BUFFER_SIZE,
+                    spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
+  auto mgmRm3100Handler =
+      new MgmRM3100Handler(objects::MGM_1_RM3100_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, 0);
+  mgmRm3100Handler->setStartUpImmediately();
+#if OBSW_TEST_ACS == 1
+  mgmRm3100Handler->setToGoToNormalMode(true);
+#endif
+
+  spiCookie =
+      new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
+                    spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
+  mgmLis3Handler =
+      new MgmLIS3MDLHandler(objects::MGM_2_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, 0);
+  mgmLis3Handler->setStartUpImmediately();
+#if OBSW_TEST_ACS == 1
+  mgmLis3Handler->setToGoToNormalMode(true);
+#endif
+
+  spiCookie =
+      new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, RM3100::MAX_BUFFER_SIZE,
+                    spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
+  mgmRm3100Handler =
+      new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, 0);
+  mgmRm3100Handler->setStartUpImmediately();
+#if OBSW_TEST_ACS == 1
+  mgmRm3100Handler->setToGoToNormalMode(true);
+#endif
+
+  spiCookie =
+      new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE,
+                    spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+  auto adisHandler =
+      new GyroADIS1650XHandler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
+                               ADIS1650X::Type::ADIS16505);
+  adisHandler->setStartUpImmediately();
+  spiCookie = new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, L3GD20H::MAX_BUFFER_SIZE,
+                            spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+  auto gyroL3gHandler =
+      new GyroHandlerL3GD20H(objects::GYRO_1_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, 0);
+  gyroL3gHandler->setStartUpImmediately();
+#if OBSW_TEST_ACS == 1
+  gyroL3gHandler->setToGoToNormalMode(true);
+#endif
+
+  spiCookie =
+      new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE,
+                    spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+  adisHandler = new GyroADIS1650XHandler(objects::GYRO_2_ADIS_HANDLER, objects::SPI_MAIN_COM_IF,
+                                         spiCookie, ADIS1650X::Type::ADIS16505);
+  adisHandler->setStartUpImmediately();
+
+  spiCookie = new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, L3GD20H::MAX_BUFFER_SIZE,
+                            spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+  gyroL3gHandler =
+      new GyroHandlerL3GD20H(objects::GYRO_3_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, 0);
+  gyroL3gHandler->setStartUpImmediately();
+#if OBSW_TEST_ACS == 1
+  gyroL3gHandler->setToGoToNormalMode(true);
+#endif
+}
+
+void ObjectFactory::createTestTasks() {
+  new TestTask(objects::TEST_TASK);
+
+#if OBSW_ADD_SPI_TEST_CODE == 1
+  new SpiTestClass(objects::SPI_TEST, gpioIF);
+#endif
+
+#if OBSW_ADD_UART_TEST_CODE == 1
+  new UartTestClass(objects::UART_TEST);
+#else
+  newSerialComIF(objects::UART_COM_IF);
+#endif
+
+#if RPI_LOOPBACK_TEST_GPIO == 1
+  GpioCookie* gpioCookieLoopback = new GpioCookie();
+  /* Loopback pins. Adapt according to setup */
+  gpioId_t gpioIdSender = gpioIds::TEST_ID_0;
+  int bcmPinSender = 26;
+  gpioId_t gpioIdReader = gpioIds::TEST_ID_1;
+  int bcmPinReader = 16;
+  gpio::createRpiGpioConfig(gpioCookieLoopback, gpioIdSender, bcmPinSender, "GPIO_LB_SENDER",
+                            gpio::Direction::OUT, 0);
+  gpio::createRpiGpioConfig(gpioCookieLoopback, gpioIdReader, bcmPinReader, "GPIO_LB_READER",
+                            gpio::Direction::IN, 0);
+  new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookieLoopback);
+#endif /* RPI_LOOPBACK_TEST_GPIO == 1 */
+
+#if RPI_TEST_ADIS16507 == 1
+  if (gpioCookie == nullptr) {
+    gpioCookie = new GpioCookie();
+  }
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_0_ADIS_CS, gpio::GYRO_0_BCM_PIN,
+                            "GYRO_0_ADIS", gpio::Direction::OUT, 1);
+  gpioIF->addGpios(gpioCookie);
+
+  spiDev = "/dev/spidev0.1";
+  spiCookie = new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, spiDev,
+                            ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE,
+                            spi::DEFAULT_ADIS16507_SPEED, nullptr, nullptr);
+  auto adisGyroHandler =
+      new GyroADIS16507Handler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
+  adisGyroHandler->setStartUpImmediately();
+#endif /* RPI_TEST_ADIS16507 == 1 */
+
+#if RPI_TEST_GPS_HANDLER == 1
+  UartCookie* uartCookie =
+      new UartCookie(objects::GPS0_HANDLER, "/dev/serial0", UartModes::CANONICAL, 9600, 1024);
+  uartCookie->setToFlushInput(true);
+  uartCookie->setReadCycles(6);
+  GPSHyperionHandler* gpsHandler =
+      new GPSHyperionHandler(objects::GPS0_HANDLER, objects::UART_COM_IF, uartCookie, false);
+  gpsHandler->setStartUpImmediately();
+#endif
+}

bsp_linux_board/ObjectFactory.h

@@ -0,0 +1,16 @@
+#ifndef BSP_LINUX_OBJECTFACTORY_H_
+#define BSP_LINUX_OBJECTFACTORY_H_
+
+#include <string>
+
+class GpioIF;
+
+namespace ObjectFactory {
+void setStatics();
+void produce(void* args);
+
+void createRpiAcsBoard(GpioIF* gpioIF, std::string spiDev);
+void createTestTasks();
+};  // namespace ObjectFactory
+
+#endif /* BSP_LINUX_OBJECTFACTORY_H_ */

bsp_linux_board/boardconfig/CMakeLists.txt

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

bsp_linux_board/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_linux_board/boardconfig/gcov.h

@@ -0,0 +1,15 @@
+#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_linux_board/boardconfig/print.c

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

bsp_linux_board/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_linux_board/boardconfig/rpiConfig.h.in

@@ -0,0 +1,20 @@
+#ifndef BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
+#define BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
+
+#include <cstdint>
+
+#define RPI_ADD_GPIO_TEST               0
+#define RPI_LOOPBACK_TEST_GPIO          0
+
+#define RPI_TEST_ADIS16507              0
+#define RPI_TEST_GPS_HANDLER            0
+
+// Only one of those 2 should be enabled!
+#define RPI_ADD_SPI_TEST                0
+#if RPI_ADD_SPI_TEST == 0
+#define RPI_TEST_ACS_BOARD              0
+#endif
+
+#define RPI_ADD_UART_TEST               0
+
+#endif /* BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_ */

bsp_linux_board/boardtest/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(${OBSW_NAME} PRIVATE)

bsp_linux_board/definitions.h

@@ -0,0 +1,43 @@
+#ifndef BSP_LINUX_BOARD_DEFINITIONS_H_
+#define BSP_LINUX_BOARD_DEFINITIONS_H_
+
+#include <cstdint>
+
+#include "OBSWConfig.h"
+
+#ifdef RASPBERRY_PI
+
+namespace spi {
+
+static constexpr char DEV[] = "/dev/spidev0.1";
+
+}
+
+namespace uart {
+
+static constexpr char DEV[] = "/dev/serial0";
+
+}
+
+/* Adapt these values accordingly */
+namespace gpio {
+static constexpr uint8_t MGM_0_BCM_PIN = 17;
+static constexpr uint8_t MGM_1_BCM_PIN = 27;
+static constexpr uint8_t MGM_2_BCM_PIN = 22;
+static constexpr uint8_t MGM_3_BCM_PIN = 23;
+static constexpr uint8_t GYRO_0_BCM_PIN = 5;
+static constexpr uint8_t GYRO_1_BCM_PIN = 6;
+static constexpr uint8_t GYRO_2_BCM_PIN = 13;
+static constexpr uint8_t GYRO_3_BCM_PIN = 19;
+
+static constexpr uint8_t SPI_MUX_0_BCM = 17;
+static constexpr uint8_t SPI_MUX_1_BCM = 27;
+static constexpr uint8_t SPI_MUX_2_BCM = 22;
+static constexpr uint8_t SPI_MUX_3_BCM = 23;
+static constexpr uint8_t SPI_MUX_4_BCM = 5;
+static constexpr uint8_t SPI_MUX_5_BCM = 6;
+}  // namespace gpio
+
+#endif
+
+#endif /* BSP_LINUX_BOARD_DEFINITIONS_H_ */

bsp_linux_board/gpioInit.cpp

@@ -0,0 +1,56 @@
+#include "gpioInit.h"
+
+#include <devices/gpioIds.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
+
+#include "definitions.h"
+#include "fsfw_hal/linux/rpi/GpioRPi.h"
+
+#ifdef RASPBERRY_PI
+
+struct MuxInfo {
+  MuxInfo(gpioId_t gpioId, int bcmNum, std::string consumer)
+      : gpioId(gpioId), bcmNum(bcmNum), consumer(consumer) {}
+  gpioId_t gpioId;
+  int bcmNum;
+  std::string consumer;
+};
+
+void rpi::gpio::initSpiCsDecoder(GpioIF* gpioComIF) {
+  using namespace ::gpio;
+  ReturnValue_t result;
+
+  if (gpioComIF == nullptr) {
+    sif::debug << "initSpiCsDecoder: Invalid gpioComIF" << std::endl;
+    return;
+  }
+
+  std::array<::MuxInfo, 6> muxInfo{
+      MuxInfo(gpioIds::SPI_MUX_BIT_0, SPI_MUX_0_BCM, "SPI_MUX_0"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_1, SPI_MUX_1_BCM, "SPI_MUX_1"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_2, SPI_MUX_2_BCM, "SPI_MUX_2"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_3, SPI_MUX_3_BCM, "SPI_MUX_3"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_4, SPI_MUX_4_BCM, "SPI_MUX_4"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_5, SPI_MUX_5_BCM, "SPI_MUX_5"),
+  };
+  GpioCookie* spiMuxGpios = new GpioCookie;
+
+  for (const auto& info : muxInfo) {
+    result = createRpiGpioConfig(spiMuxGpios, info.gpioId, info.bcmNum, info.consumer,
+                                 Direction::OUT, Levels::LOW);
+    if (result != returnvalue::OK) {
+      sif::error << "Creating Raspberry Pi SPI Mux GPIO failed with code " << result << std::endl;
+      return;
+    }
+  }
+
+  result = gpioComIF->addGpios(spiMuxGpios);
+  if (result != returnvalue::OK) {
+    sif::error << "initSpiCsDecoder: Failed to add mux bit gpios to gpioComIF" << std::endl;
+    return;
+  }
+}
+
+#endif

bsp_linux_board/gpioInit.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "OBSWConfig.h"
+
+class GpioIF;
+
+#ifdef RASPBERRY_PI
+namespace rpi {
+namespace gpio {
+
+/**
+ * @brief   This function initializes the GPIOs used to control the SN74LVC138APWR decoders on
+ *          the TCS Board and the interface board.
+ */
+void initSpiCsDecoder(GpioIF* gpioComIF);
+
+}  // namespace gpio
+}  // namespace rpi
+
+#endif

bsp_linux_board/main.cpp

@@ -0,0 +1,34 @@
+#include <iostream>
+
+#include "InitMission.h"
+#include "OBSWConfig.h"
+#include "OBSWVersion.h"
+#include "fsfw/tasks/TaskFactory.h"
+#include "fsfw/version.h"
+
+#ifdef RASPBERRY_PI
+static const char* const BOARD_NAME = "Raspberry Pi";
+#elif defined(BEAGLEBONEBLACK)
+static const char* const BOARD_NAME = "Beaglebone Black";
+#else
+static const char* const BOARD_NAME = "Unknown Board";
+#endif
+
+/**
+ * @brief 	    This is the main program and entry point for the Raspberry Pi.
+ * @return
+ */
+int main(void) {
+  std::cout << "-- EIVE OBSW --" << std::endl;
+  std::cout << "-- Compiled for Linux board " << BOARD_NAME << " --" << std::endl;
+  std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
+            << SW_REVISION << ", FSFW v" << fsfw::FSFW_VERSION << " --" << std::endl;
+  std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
+
+  initmission::initMission();
+
+  for (;;) {
+    /* Suspend main thread by sleeping it. */
+    TaskFactory::delayTask(5000);
+  }
+}