CMakeLists.txt

@@ -14,7 +14,7 @@ cmake_minimum_required(VERSION 3.13)
 set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 if(TGT_BSP MATCHES "arm/q7s")
-    option(EIVE_BUILD_WATCHDOG "Compile the OBSW watchdog insted" OFF)
+    option(EIVE_BUILD_WATCHDOG "Compile the OBSW watchdog instead" OFF)
     option(BUILD_Q7S_SIMPLE_MODE OFF "Simple mode with a minimal main function")
 endif()
 
@@ -104,7 +104,7 @@ pre_source_hw_os_config()
 
 if(TGT_BSP)
     if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/raspberrypi"
-        OR TGT_BSP MATCHES "arm/beagleboneblack"
+        OR TGT_BSP MATCHES "arm/beagleboneblack" OR TGT_BSP MATCHES "arm/egse"
     )
         set(FSFW_CONFIG_PATH "linux/fsfwconfig")
         if(NOT BUILD_Q7S_SIMPLE_MODE)
@@ -114,11 +114,17 @@ if(TGT_BSP)
         endif()
     endif()
    
-    if(TGT_BSP MATCHES "arm/raspberrypi")
+    if(TGT_BSP MATCHES "arm/raspberrypi" )
         # Used by configure file
         set(RASPBERRY_PI ON)
         set(FSFW_HAL_ADD_RASPBERRY_PI ON)
     endif()
+
+    if(TGT_BSP MATCHES "arm/egse")
+        # Used by configure file
+        set(EGSE ON)
+        set(FSFW_HAL_ADD_LIBGPIOD OFF)
+    endif()
     
     if(TGT_BSP MATCHES "arm/beagleboneblack")
         # Used by configure file
@@ -146,7 +152,7 @@ if(NOT EIVE_BUILD_WATCHDOG)
     configure_file(${FSFW_CONFIG_PATH}/OBSWConfig.h.in OBSWConfig.h)
     if(TGT_BSP MATCHES "arm/q7s")
         configure_file(${BSP_PATH}/boardconfig/q7sConfig.h.in q7sConfig.h)
-    elseif(TGT_BSP MATCHES "arm/raspberrypi")
+    elseif(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/egse")
         configure_file(${BSP_PATH}/boardconfig/rpiConfig.h.in rpiConfig.h)
     endif()
 endif()
@@ -258,6 +264,12 @@ target_link_libraries(${TARGET_NAME} PRIVATE
     ${LIB_CXX_FS}
 )
 
+if(TGT_BSP MATCHES "arm/egse")
+target_link_libraries(${TARGET_NAME} PRIVATE
+	${LIB_ARCSEC}
+	)
+endif()
+
 # Add include paths for all sources.
 target_include_directories(${TARGET_NAME} PRIVATE
 	${CMAKE_CURRENT_SOURCE_DIR}
@@ -266,7 +278,7 @@ target_include_directories(${TARGET_NAME} PRIVATE
 	${LIB_ARCSEC_PATH}
 )	
 
-if(TGT_BSP MATCHES "arm/q7s")
+if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/egse")
     target_include_directories(${TARGET_NAME} PRIVATE
         ${ARCSEC_LIB_PATH}
     )

bsp_egse/CMakeLists.txt

@@ -0,0 +1,7 @@
+target_sources(${TARGET_NAME} PUBLIC
+	InitMission.cpp
+	main.cpp
+	ObjectFactory.cpp
+)
+
+add_subdirectory(boardconfig)

bsp_egse/InitMission.cpp

@@ -0,0 +1,188 @@
+#include "InitMission.h"
+
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+#include <fsfw/tasks/PeriodicTaskIF.h>
+#include <fsfw/tasks/TaskFactory.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 = HasReturnvaluesIF::RETURN_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 != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+
+  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
+      "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
+  if (result != HasReturnvaluesIF::RETURN_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 != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Add component TMTC Polling failed" << std::endl;
+  }
+
+  /* PUS Services */
+  std::vector<PeriodicTaskIF*> pusTasks;
+  createPusTasks(*factory, missedDeadlineFunc, pusTasks);
+
+  std::vector<PeriodicTaskIF*> pstTasks;
+  FixedTimeslotTaskIF* pst = factory->createFixedTimeslotTask(
+      "STAR_TRACKER_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
+  result = pst::pstUart(pst);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+  }
+  pstTasks.push_back(pst);
+
+  PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
+      "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = strHelperTask->addComponent(objects::STR_HELPER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
+  }
+  pstTasks.push_back(strHelperTask);
+
+  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(pstTasks, "PST Tasks");
+  taskStarter(pusTasks, "PST Tasks");
+
+  sif::info << "Tasks started.." << std::endl;
+}
+
+void initmission::createPusTasks(TaskFactory& factory,
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_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 != HasReturnvaluesIF::RETURN_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 != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
+  }
+  result = pusEvents->addComponent(objects::EVENT_MANAGER);
+  if (result != HasReturnvaluesIF::RETURN_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 != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  }
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_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 != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+  if (result != HasReturnvaluesIF::RETURN_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 != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
+  }
+  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
+  }
+  taskVec.push_back(pusLowPrio);
+}

bsp_egse/InitMission.h

@@ -0,0 +1,23 @@
+#ifndef BSP_LINUX_INITMISSION_H_
+#define BSP_LINUX_INITMISSION_H_
+
+#include <vector>
+
+#include "fsfw/tasks/Typedef.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_egse/ObjectFactory.cpp

@@ -0,0 +1,53 @@
+#include "ObjectFactory.h"
+
+#include <devConf.h>
+#include <mission/devices/GPSHyperionHandler.h>
+
+#include "OBSWConfig.h"
+#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/tmtcpacket/pus/tm.h"
+#include "fsfw/tmtcservices/CommandingServiceBase.h"
+#include "fsfw/tmtcservices/PusServiceBase.h"
+#include "mission/core/GenericFactory.h"
+#include "mission/utility/TmFunnel.h"
+#include "objects/systemObjectList.h"
+#include "tmtc/apid.h"
+#include "tmtc/pusIds.h"
+#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
+#include "linux/devices/startracker/StarTrackerHandler.h"
+
+#include <fsfw/src/fsfw/osal/common/TcpTmTcBridge.h>
+#include <fsfw/src/fsfw/osal/common/TcpTmTcServer.h>
+
+#include <fsfw_hal/linux/uart/UartComIF.h>
+#include <fsfw_hal/linux/uart/UartCookie.h>
+
+void Factory::setStaticFrameworkObjectIds() {
+  PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
+  PusServiceBase::packetDestination = 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;
+
+  VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+  TmPacketBase::timeStamperId = objects::TIME_STAMPER;
+}
+
+void ObjectFactory::produce(void* args) {
+  Factory::setStaticFrameworkObjectIds();
+  ObjectFactory::produceGenericObjects();
+
+  UartCookie* starTrackerCookie =
+      new UartCookie(objects::STAR_TRACKER, "/dev/serial0", UartModes::NON_CANONICAL,
+                     uart::STAR_TRACKER_BAUD, StarTracker::MAX_FRAME_SIZE * 2 + 2);
+  new UartComIF(objects::UART_COM_IF);
+  starTrackerCookie->setNoFixedSizeReply();
+  StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
+  StarTrackerHandler* starTrackerHandler = new StarTrackerHandler(
+      objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie, strHelper);
+  starTrackerHandler->setStartUpImmediately();
+}

bsp_egse/ObjectFactory.h

@@ -0,0 +1,11 @@
+#ifndef BSP_LINUX_OBJECTFACTORY_H_
+#define BSP_LINUX_OBJECTFACTORY_H_
+
+namespace ObjectFactory {
+void setStatics();
+void produce(void* args);
+
+void createTestTasks();
+};  // namespace ObjectFactory
+
+#endif /* BSP_LINUX_OBJECTFACTORY_H_ */

bsp_egse/boardconfig/CMakeLists.txt

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

bsp_egse/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_egse/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_egse/boardconfig/print.c

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

bsp_egse/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_egse/boardconfig/rpiConfig.h.in

@@ -0,0 +1,6 @@
+#ifndef BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
+#define BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
+
+#include <cstdint>
+
+#endif /* BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_ */

bsp_egse/main.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+
+#include "InitMission.h"
+#include "OBSWConfig.h"
+#include "OBSWVersion.h"
+#include "fsfw/FSFWVersion.h"
+#include "fsfw/tasks/TaskFactory.h"
+
+/**
+ * @brief 	    This is the main program and entry point for egse (raspberry pi 4)
+ * @return
+ */
+int main(void) {
+  std::cout << "-- EIVE OBSW --" << std::endl;
+  std::cout << "-- Compiled for EGSE from Arcsec" << " --" << std::endl;
+  std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
+            << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << FSFW_REVISION
+            << "--" << std::endl;
+  std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
+
+  initmission::initMission();
+
+  for (;;) {
+    /* Suspend main thread by sleeping it. */
+    TaskFactory::delayTask(5000);
+  }
+}

bsp_linux_board/InitMission.cpp

@@ -63,30 +63,38 @@ void initmission::initTasks() {
     sif::error << "Object add component failed" << std::endl;
   }
 
-  /* UDP bridge */
-  PeriodicTaskIF* udpBridgeTask = factory->createPeriodicTask(
-      "UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-  result = udpBridgeTask->addComponent(objects::TMTC_BRIDGE);
+  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
+      "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "Add component UDP Unix Bridge failed" << std::endl;
+    sif::error << "Add component TMTC Bridge failed" << std::endl;
   }
-  PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
-      "UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-  result = udpPollingTask->addComponent(objects::TMTC_POLLING_TASK);
+  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
+      "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "Add component UDP Polling failed" << std::endl;
+    sif::error << "Add component TMTC Polling failed" << std::endl;
   }
 
   /* 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 */
+  FixedTimeslotTaskIF* pst = factory.createFixedTimeslotTask(
+      "STAR_TRACKER_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
+  result = pst::pstUart(Pst);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+  }
+  taskVec.push_back(pst);
+
+  PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
+      "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = strHelperTask->addComponent(objects::STR_HELPER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
+  }
+  taskvec.push_back(strHelperTask);
 
   auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
     for (const auto& task : taskVector) {
@@ -99,21 +107,12 @@ void initmission::initTasks() {
   };
 
   sif::info << "Starting tasks.." << std::endl;
-  tmTcDistributor->startTask();
-  udpBridgeTask->startTask();
-  udpPollingTask->startTask();
+  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_TEST_PST == 1
-  if (startTestPst) {
-    pstTestTask->startTask();
-  }
-#endif /* RPI_TEST_ACS_BOARD == 1 */
   sif::info << "Tasks started.." << std::endl;
 }
 
@@ -185,60 +184,3 @@ void initmission::createPusTasks(TaskFactory& factory,
   }
   taskVec.push_back(pusLowPrio);
 }
-
-void initmission::createPstTasks(TaskFactory& factory,
-                                 TaskDeadlineMissedFunction missedDeadlineFunc,
-                                 std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-#if OBSW_ADD_SPI_TEST_CODE == 0
-  FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
-      "SPI_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
-  result = pst::pstSpi(spiPst);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
-  }
-  taskVec.push_back(spiPst);
-#endif
-}
-
-void initmission::createTestTasks(TaskFactory& factory,
-                                  TaskDeadlineMissedFunction missedDeadlineFunc,
-                                  std::vector<PeriodicTaskIF*>& taskVec) {
-  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-  PeriodicTaskIF* testTask = factory.createPeriodicTask(
-      "TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-  result = testTask->addComponent(objects::TEST_TASK);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
-  }
-#if RPI_ADD_SPI_TEST == 1
-  result = testTask->addComponent(objects::SPI_TEST);
-  if (result != HasReturnvaluesIF::RETURN_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 != HasReturnvaluesIF::RETURN_OK) {
-    initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
-  }
-#endif /* RPI_ADD_GPIO_TEST == 1 */
-#if RPI_ADD_UART_TEST == 1
-  result = testTask->addComponent(objects::UART_TEST);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
-  }
-#endif /* RPI_ADD_GPIO_TEST == 1 */
-
-  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 != HasReturnvaluesIF::RETURN_OK) {
-    sif::info << "initmission::initTasks: ACS PST empty or invalid" << std::endl;
-    startTestPst = false;
-  }
-#endif /* RPI_TEST_ACS_BOARD == 1 */
-}

bsp_linux_board/boardconfig/print.c

@@ -1,4 +1,4 @@
-#include <bsp_q7s/boardconfig/print.h>
+#include <bsp_linux_board/boardconfig/print.h>
 #include <stdio.h>
 
 void printChar(const char* character, bool errStream) {

bsp_q7s/core/InitMission.cpp

@@ -86,7 +86,7 @@ void initmission::initTasks() {
       "TCPIP_TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    initmission::printAddObjectError("UDP_BRIDGE", objects::TMTC_BRIDGE);
+    initmission::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE);
   }
   PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
       "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
@@ -135,9 +135,9 @@ void initmission::initTasks() {
   }
 
 #if OBSW_ADD_STAR_TRACKER == 1
-  PeriodicTaskIF* strImgLoaderTask = factory->createPeriodicTask(
+  PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
       "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-  result = strImgLoaderTask->addComponent(objects::STR_HELPER);
+  result = strHelperTask->addComponent(objects::STR_HELPER);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
   }
@@ -204,7 +204,7 @@ void initmission::initTasks() {
 #if BOARD_TE0720 == 0
   fsTask->startTask();
 #if OBSW_ADD_STAR_TRACKER == 1
-  strImgLoaderTask->startTask();
+  strHelperTask >startTask();
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 #endif
 

bsp_q7s/devices/CMakeLists.txt

@@ -2,6 +2,4 @@ target_sources(${TARGET_NAME} PRIVATE
     PlocSupervisorHandler.cpp
     PlocUpdater.cpp
     PlocMemoryDumper.cpp
-)
-
-add_subdirectory(startracker)
+)

cmake/HardwareOsPreConfig.cmake

@@ -47,7 +47,7 @@ if(CMAKE_CROSSCOMPILING)
 	
 	set_property(CACHE TGT_BSP 
 		PROPERTY STRINGS  
-		"arm/q7s" "arm/raspberrypi" 
+		"arm/q7s" "arm/raspberrypi" "arm/egse"
 	)
 endif()
 	
@@ -57,6 +57,8 @@ if(TGT_BSP)
 		set(BSP_PATH "bsp_linux_board")
 	elseif(TGT_BSP MATCHES "arm/q7s")
 		set(BSP_PATH "bsp_q7s")
+  elseif(TGT_BSP MATCHES "arm/egse")
+    set(BSP_PATH "bsp_egse")
 	else() 
 		message(WARNING "CMake not configured for this target!")
 		message(FATAL_ERROR "Target: ${TGT_BSP}!")

cmake/PreProjectConfig.cmake

@@ -16,7 +16,7 @@ if(FSFW_OSAL MATCHES linux AND TGT_BSP)
 			"${CMAKE_SCRIPT_PATH}/Q7SCrossCompileConfig.cmake"
 			PARENT_SCOPE
 		)
-	elseif(TGT_BSP MATCHES "arm/raspberrypi")
+	elseif(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/egse")
 		if(NOT DEFINED ENV{LINUX_ROOTFS})
 			if(NOT DEFINED LINUX_ROOTFS)
 			    message(WARNING "No LINUX_ROOTFS environmental or CMake variable set!")

cmake/scripts/egse/egse_path_helper_win.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+# Script to set path to raspberry pi toolchain
+# Run script with: source egse_path_helper_win.sh
+TOOLCHAIN_PATH="/c/SysGCC/raspberry/bin"
+if [ $# -eq 1 ];then
+	export PATH=$PATH:"$1"
+else
+	echo "Path of toolchain set to $TOOLCHAIN_PATH"
+	export PATH=$PATH:$TOOLCHAIN_PATH
+fi
+
+export CROSS_COMPILE="arm-linux-gnueabihf"
+export RASPBERRY_VERSION="4"

cmake/scripts/egse/make-debug-cfg.sh

@@ -0,0 +1,34 @@
+#!/bin/sh
+counter=0
+cfg_script_name="cmake-build-cfg.py"
+while [ ${counter} -lt 5 ]
+do
+    cd ..
+    if [ -f ${cfg_script_name} ];then
+        break
+    fi
+    counter=$((counter=counter + 1))
+done
+
+if [ "${counter}" -ge 5 ];then
+    echo "${cfg_script_name} not found in upper directories!"
+    exit 1
+fi
+
+
+os_fsfw="linux"
+tgt_bsp="arm/egse"
+build_generator="make"
+build_dir="build-Debug-egse"
+if [ "${OS}" = "Windows_NT" ]; then
+    python="py"
+# Could be other OS but this works for now.
+else
+    python="python3"
+fi
+
+echo "Running command (without the leading +):"
+set -x # Print command 
+${python} ${cfg_script_name} -o "${os_fsfw}" -g "${build_generator}" -b "debug" -t "${tgt_bsp}" \
+	-l"${build_dir}"
+# set +x

common/config/devConf.h

@@ -42,9 +42,9 @@ namespace uart {
 static constexpr size_t HYPERION_GPS_REPLY_MAX_BUFFER = 1024;
 static constexpr uint32_t SYRLINKS_BAUD = 38400;
 static constexpr uint32_t GNSS_BAUD = 9600;
-static constexpr uint32_t PLOC_MPSOC_BAUD = 115200;
+static constexpr uint32_t PLOC_MPSOC_BAUD = 921600;
 static constexpr uint32_t PLOC_SUPERVISOR_BAUD = 115200;
-static constexpr uint32_t STAR_TRACKER_BAUD = 115200;
+static constexpr uint32_t STAR_TRACKER_BAUD = 921600;
 
 }
 

linux/boardtest/SpiTestClass.cpp

@@ -279,66 +279,66 @@ void SpiTestClass::acsInit() {
 #ifdef RASPBERRY_PI
   GpiodRegularByChip *gpio = nullptr;
   std::string rpiGpioName = "gpiochip0";
-  gpio = new GpiodRegularByChip(rpiGpioName, mgm0Lis3mdlChipSelect, "MGM_0_LIS3", gpio::DIR_OUT,
+  gpio = new GpiodRegularByChip(rpiGpioName, mgm0Lis3mdlChipSelect, "MGM_0_LIS3", gpio::OUT,
                                 gpio::HIGH);
   gpioCookie->addGpio(gpioIds::MGM_0_LIS3_CS, gpio);
 
-  gpio = new GpiodRegularByChip(rpiGpioName, mgm1Rm3100ChipSelect, "MGM_1_RM3100", gpio::DIR_OUT,
+  gpio = new GpiodRegularByChip(rpiGpioName, mgm1Rm3100ChipSelect, "MGM_1_RM3100", gpio::OUT,
                                 gpio::HIGH);
   gpioCookie->addGpio(gpioIds::MGM_1_RM3100_CS, gpio);
 
-  gpio = new GpiodRegularByChip(rpiGpioName, gyro0AdisChipSelect, "GYRO_0_ADIS", gpio::DIR_OUT,
+  gpio = new GpiodRegularByChip(rpiGpioName, gyro0AdisChipSelect, "GYRO_0_ADIS", gpio::OUT,
                                 gpio::HIGH);
   gpioCookie->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio);
 
-  gpio = new GpiodRegularByChip(rpiGpioName, gyro1L3gd20ChipSelect, "GYRO_1_L3G", gpio::DIR_OUT,
+  gpio = new GpiodRegularByChip(rpiGpioName, gyro1L3gd20ChipSelect, "GYRO_1_L3G", gpio::OUT,
                                 gpio::HIGH);
   gpioCookie->addGpio(gpioIds::GYRO_1_L3G_CS, gpio);
 
-  gpio = new GpiodRegularByChip(rpiGpioName, gyro3L3gd20ChipSelect, "GYRO_2_L3G", gpio::DIR_OUT,
+  gpio = new GpiodRegularByChip(rpiGpioName, gyro3L3gd20ChipSelect, "GYRO_2_L3G", gpio::OUT,
                                 gpio::HIGH);
   gpioCookie->addGpio(gpioIds::GYRO_3_L3G_CS, gpio);
 
-  gpio = new GpiodRegularByChip(rpiGpioName, mgm2Lis3mdlChipSelect, "MGM_2_LIS3", gpio::DIR_OUT,
+  gpio = new GpiodRegularByChip(rpiGpioName, mgm2Lis3mdlChipSelect, "MGM_2_LIS3", gpio::OUT,
                                 gpio::HIGH);
   gpioCookie->addGpio(gpioIds::MGM_2_LIS3_CS, gpio);
 
-  gpio = new GpiodRegularByChip(rpiGpioName, mgm3Rm3100ChipSelect, "MGM_3_RM3100", gpio::DIR_OUT,
+  gpio = new GpiodRegularByChip(rpiGpioName, mgm3Rm3100ChipSelect, "MGM_3_RM3100", gpio::OUT,
                                 gpio::HIGH);
   gpioCookie->addGpio(gpioIds::MGM_3_RM3100_CS, gpio);
 #elif defined(XIPHOS_Q7S)
   GpiodRegularByLineName *gpio = nullptr;
   gpio =
-      new GpiodRegularByLineName(q7s::gpioNames::MGM_0_CS, "MGM_0_LIS3", gpio::DIR_OUT, gpio::HIGH);
+      new GpiodRegularByLineName(q7s::gpioNames::MGM_0_CS, "MGM_0_LIS3", gpio::OUT, gpio::HIGH);
   gpioCookie->addGpio(gpioIds::MGM_0_LIS3_CS, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_1_CS, "MGM_1_RM3100", gpio::DIR_OUT,
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_1_CS, "MGM_1_RM3100", gpio::OUT,
                                     gpio::HIGH);
   gpioCookie->addGpio(gpioIds::MGM_1_RM3100_CS, gpio);
   gpio =
-      new GpiodRegularByLineName(q7s::gpioNames::MGM_2_CS, "MGM_2_LIS3", gpio::DIR_OUT, gpio::HIGH);
+      new GpiodRegularByLineName(q7s::gpioNames::MGM_2_CS, "MGM_2_LIS3", gpio::OUT, gpio::HIGH);
   gpioCookie->addGpio(gpioIds::MGM_2_LIS3_CS, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_1_CS, "MGM_3_RM3100", gpio::DIR_OUT,
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_1_CS, "MGM_3_RM3100", gpio::OUT,
                                     gpio::HIGH);
   gpioCookie->addGpio(gpioIds::MGM_3_RM3100_CS, gpio);
 
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ADIS_CS, "GYRO_0_ADIS", gpio::DIR_OUT,
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ADIS_CS, "GYRO_0_ADIS", gpio::OUT,
                                     gpio::HIGH);
   gpioCookie->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_1_L3G_CS, "GYRO_1_L3G", gpio::DIR_OUT,
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_1_L3G_CS, "GYRO_1_L3G", gpio::OUT,
                                     gpio::HIGH);
   gpioCookie->addGpio(gpioIds::GYRO_1_L3G_CS, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ADIS_CS, "GYRO_2_ADIS", gpio::DIR_OUT,
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ADIS_CS, "GYRO_2_ADIS", gpio::OUT,
                                     gpio::HIGH);
   gpioCookie->addGpio(gpioIds::GYRO_2_ADIS_CS, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_3_L3G_CS, "GYRO_3_L3G", gpio::DIR_OUT,
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_3_L3G_CS, "GYRO_3_L3G", gpio::OUT,
                                     gpio::HIGH);
   gpioCookie->addGpio(gpioIds::GYRO_3_L3G_CS, gpio);
 
   // Enable pins must be pulled low for regular operations
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ENABLE, "GYRO_0_ENABLE", gpio::DIR_OUT,
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ENABLE, "GYRO_0_ENABLE", gpio::OUT,
                                     gpio::LOW);
   gpioCookie->addGpio(gpioIds::GYRO_0_ENABLE, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ENABLE, "GYRO_2_ENABLE", gpio::DIR_OUT,
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ENABLE, "GYRO_2_ENABLE", gpio::OUT,
                                     gpio::LOW);
   gpioCookie->addGpio(gpioIds::GYRO_2_ENABLE, gpio);
 #endif

linux/devices/CMakeLists.txt

@@ -2,3 +2,5 @@ target_sources(${TARGET_NAME} PRIVATE
 	SolarArrayDeploymentHandler.cpp
 	SusHandler.cpp
 )
+
+add_subdirectory(startracker)

linux/devices/devicedefinitions/StarTrackerDefinitions.h

@@ -1,5 +1,5 @@
-#ifndef MISSION_STARTRACKER_DEFINITIONS_H_
-#define MISSION_STARTRACKER_DEFINITIONS_H_
+#ifndef LINUX_DEVICES_DEVICEDEFINITIONS_DEFINITIONS_H_
+#define LINUX_DEVICES_DEVICEDEFINITIONS_DEFINITIONS_H_
 
 #include <fsfw/datapool/PoolReadGuard.h>
 #include <fsfw/datapoollocal/LocalPoolVariable.h>
@@ -1203,4 +1203,4 @@ class LimitsSet : public StaticLocalDataSet<LIMITS_SET_ENTRIES> {
   }
 };
 }  // namespace StarTracker
-#endif /* MISSION_STARTRACKER_DEFINITIONS_H_ */
+#endif /* LINUX_DEVICES_DEVICEDEFINITIONS_DEFINITIONS_H_ */

linux/devices/startracker/ArcsecDatalinkLayer.h

@@ -1,7 +1,7 @@
 #ifndef BSP_Q7S_DEVICES_ARCSECDATALINKLAYER_H_
 #define BSP_Q7S_DEVICES_ARCSECDATALINKLAYER_H_
 
-#include "StarTrackerDefinitions.h"
+#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 extern "C" {

linux/devices/startracker/ArcsecJsonParamBase.h

@@ -5,7 +5,7 @@
 #include <fstream>
 #include <nlohmann/json.hpp>
 
-#include "StarTrackerDefinitions.h"
+#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 extern "C" {

linux/devices/startracker/StarTrackerHandler.h

@@ -5,7 +5,7 @@
 
 #include "ArcsecDatalinkLayer.h"
 #include "ArcsecJsonParamBase.h"
-#include "StarTrackerDefinitions.h"
+#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
 #include "StrHelper.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "fsfw/src/fsfw/serialize/SerializeAdapter.h"

linux/devices/startracker/StrHelper.cpp

@@ -11,11 +11,13 @@ StrHelper::StrHelper(object_id_t objectId) : SystemObject(objectId) {}
 StrHelper::~StrHelper() {}
 
 ReturnValue_t StrHelper::initialize() {
+#ifdef XIPHOS_Q7S
   sdcMan = SdCardManager::instance();
   if (sdcMan == nullptr) {
     sif::warning << "StrHelper::initialize: Invalid SD Card Manager" << std::endl;
     return RETURN_FAILED;
   }
+#endif
   return RETURN_OK;
 }
 
@@ -107,10 +109,12 @@ ReturnValue_t StrHelper::setComIF(DeviceCommunicationIF* communicationInterface_
 void StrHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; }
 
 ReturnValue_t StrHelper::startImageUpload(std::string fullname) {
+#ifdef XIPHOS_Q7S
   ReturnValue_t result = checkPath(fullname);
   if (result != RETURN_OK) {
     return result;
   }
+#endif
   uploadImage.uploadFile = fullname;
   if (not std::filesystem::exists(fullname)) {
     return FILE_NOT_EXISTS;
@@ -122,10 +126,12 @@ ReturnValue_t StrHelper::startImageUpload(std::string fullname) {
 }
 
 ReturnValue_t StrHelper::startImageDownload(std::string path) {
+#ifdef XIPHOS_Q7S
   ReturnValue_t result = checkPath(path);
   if (result != RETURN_OK) {
     return result;
   }
+#endif
   if (not std::filesystem::exists(path)) {
     return PATH_NOT_EXISTS;
   }
@@ -145,10 +151,12 @@ void StrHelper::setFlashReadFilename(std::string filename) { flashRead.filename
 void StrHelper::setDownloadFpgaImage(std::string filename) { fpgaDownload.fileName = filename; }
 
 ReturnValue_t StrHelper::startFlashWrite(std::string fullname, uint8_t region, uint32_t address) {
+#ifdef XIPHOS_Q7S
   ReturnValue_t result = checkPath(fullname);
   if (result != RETURN_OK) {
     return result;
   }
+#endif
   flashWrite.fullname = fullname;
   if (not std::filesystem::exists(flashWrite.fullname)) {
     return FILE_NOT_EXISTS;
@@ -163,10 +171,12 @@ ReturnValue_t StrHelper::startFlashWrite(std::string fullname, uint8_t region, u
 
 ReturnValue_t StrHelper::startFlashRead(std::string path, uint8_t region, uint32_t address,
                                         uint32_t length) {
+#ifdef XIPHOS_Q7S
   ReturnValue_t result = checkPath(path);
   if (result != RETURN_OK) {
     return result;
   }
+#endif
   flashRead.path = path;
   if (not std::filesystem::exists(flashRead.path)) {
     return FILE_NOT_EXISTS;
@@ -664,6 +674,7 @@ ReturnValue_t StrHelper::checkFpgaActionReply(uint32_t expectedPosition, uint32_
   return result;
 }
 
+#ifdef XIPHOS_Q7S
 ReturnValue_t StrHelper::checkPath(std::string name) {
   if (name.substr(0, sizeof(SdCardManager::SD_0_MOUNT_POINT)) ==
       std::string(SdCardManager::SD_0_MOUNT_POINT)) {
@@ -680,6 +691,7 @@ ReturnValue_t StrHelper::checkPath(std::string name) {
   }
   return RETURN_OK;
 }
+#endif
 
 void StrHelper::printProgress(uint32_t itemsTransferred, uint32_t fullNumItems) {
     float progressInPercent =

linux/devices/startracker/StrHelper.h

@@ -4,7 +4,11 @@
 #include <string>
 
 #include "ArcsecDatalinkLayer.h"
+
+#ifdef XIPHOS_Q7S
 #include "bsp_q7s/memory/SdCardManager.h"
+#endif
+
 #include "fsfw/devicehandlers/CookieIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/osal/linux/BinarySemaphore.h"
@@ -287,7 +291,9 @@ class StrHelper : public SystemObject, public ExecutableObjectIF, public HasRetu
   };
   FlashRead flashRead;
 
+#ifdef XIPHOS_Q7S
   SdCardManager* sdcMan = nullptr;
+#endif
 
   uint8_t commandBuffer[StarTracker::MAX_FRAME_SIZE];
 
@@ -389,12 +395,14 @@ class StrHelper : public SystemObject, public ExecutableObjectIF, public HasRetu
    */
   ReturnValue_t checkFpgaActionReply(uint32_t expectedPosition, uint32_t expectedLength);
 
+#ifdef XIPHOS_Q7S
   /**
    * @brief   Checks if a path points to an sd card and whether the SD card is monuted.
    *
    * @return  SD_NOT_MOUNTED id SD card is not mounted, otherwise RETURN_OK
    */
   ReturnValue_t checkPath(std::string name);
+#endif
 
   /**
    * @brief Prints progress of transfer which can be useful for large data transfers

linux/fsfwconfig/OBSWConfig.h.in

@@ -9,6 +9,7 @@
 #cmakedefine RASPBERRY_PI
 #cmakedefine XIPHOS_Q7S
 #cmakedefine BEAGLEBONEBLACK
+#cmakedefine EGSE
 
 #ifdef RASPBERRY_PI
 #include "rpiConfig.h"

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -526,6 +526,7 @@ ReturnValue_t pst::pstI2c(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
 #endif
+  static_cast<void>(length);
   if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "I2C PST initialization failed" << std::endl;
     return HasReturnvaluesIF::RETURN_FAILED;

scripts/egse-port.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+echo "-L 1534:localhost:1534 portforwarding for tcf agent"
+echo "-L 1537:192.168.133.10:7301 for TMTC commanding using the TCP/IP IF"
+
+ssh -L 1534:localhost:1534 pi@192.168.18.31
+ssh -L 1537:localhost:7301 pi@192.168.18.31