Init commit

bsp_hosted/CMakeLists.txt

@@ -0,0 +1,13 @@
+target_sources(${TARGET_NAME} 
+	PRIVATE
+		main.cpp
+)
+
+add_subdirectory(core)
+add_subdirectory(fsfwconfig)
+add_subdirectory(utility)
+
+target_include_directories(${TARGET_NAME} 
+	PRIVATE
+		${CMAKE_CURRENT_SOURCE_DIR}
+)

bsp_hosted/bsp_hosted.mk

@@ -0,0 +1,9 @@
+CSRC += $(wildcard $(CURRENTPATH)/*.c)
+CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
+
+CSRC += $(wildcard $(CURRENTPATH)/core/*.c)
+CXXSRC += $(wildcard $(CURRENTPATH)/core/*.cpp)
+
+CSRC += $(wildcard $(CURRENTPATH)/utility/*.c)
+
+INCLUDES += $(CURRENTPATH)

bsp_hosted/core/CMakeLists.txt

@@ -0,0 +1,5 @@
+target_sources(${TARGET_NAME} 
+	PRIVATE
+		InitMission.cpp
+		ObjectFactory.cpp
+)

bsp_hosted/core/InitMission.cpp

@@ -0,0 +1,265 @@
+#include <OBSWConfig.h>
+
+#include <bsp_hosted/core/InitMission.h>
+#include <bsp_hosted/fsfwconfig/objects/systemObjectList.h>
+#include <bsp_hosted/fsfwconfig/pollingsequence/pollingSequenceFactory.h>
+
+#include <mission/utility/TaskCreation.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>
+
+#ifdef _WIN32
+#include <fsfw/osal/windows/winTaskHelpers.h>
+#endif
+
+
+void InitMission::createTasks() {
+    TaskFactory* taskFactory = TaskFactory::instance();
+    if(taskFactory == nullptr) {
+        return;
+    }
+
+    TaskPriority currPrio;
+#ifdef _WIN32
+    currPrio = tasks::makeWinPriority();
+#endif
+
+    TaskDeadlineMissedFunction deadlineMissedFunc = nullptr;
+#if OBSW_PRINT_MISSED_DEADLINES == 1
+    deadlineMissedFunc = TaskFactory::printMissedDeadline;
+#endif
+
+#if OBSW_ADD_CORE_COMPONENTS == 1
+
+#ifdef __unix__
+    currPrio = 40;
+#endif
+    /* TMTC Distribution */
+    PeriodicTaskIF* distributerTask = taskFactory->createPeriodicTask(
+            "DIST", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.1, deadlineMissedFunc);
+    ReturnValue_t result = distributerTask->addComponent(
+            objects::CCSDS_DISTRIBUTOR);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("CCSDS distributor", objects::CCSDS_DISTRIBUTOR);
+    }
+    result = distributerTask->addComponent(objects::PUS_DISTRIBUTOR);
+    if (result!=HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("PUS distributor", objects::PUS_DISTRIBUTOR);
+    }
+    result = distributerTask->addComponent(objects::TM_FUNNEL);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("TM funnel", objects::TM_FUNNEL);
+    }
+
+#ifdef __unix__
+    currPrio = 50;
+#endif
+    /* UDP bridge */
+    PeriodicTaskIF* udpBridgeTask = taskFactory->createPeriodicTask(
+            "UDP_UNIX_BRIDGE", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2,
+            deadlineMissedFunc
+    );
+    result = udpBridgeTask->addComponent(objects::UDP_BRIDGE);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("UDP bridge", objects::UDP_BRIDGE);
+    }
+
+#ifdef __unix__
+    currPrio = 80;
+#endif
+    PeriodicTaskIF* udpPollingTask = taskFactory->createPeriodicTask(
+            "UDP_POLLING", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, deadlineMissedFunc
+    );
+    result = udpPollingTask->addComponent(objects::UDP_POLLING_TASK);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("UDP polling", objects::UDP_POLLING_TASK);
+    }
+
+#ifdef __unix__
+    currPrio = 20;
+#endif
+    PeriodicTaskIF* eventTask = taskFactory->createPeriodicTask(
+            "EVENT", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.100, deadlineMissedFunc
+    );
+    result = eventTask->addComponent(objects::EVENT_MANAGER);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("Event Manager", objects::EVENT_MANAGER);
+    }
+#endif /* OBSW_ADD_CORE_COMPONENTS == 1 */
+
+#if OBSW_ADD_TASK_EXAMPLE == 1
+
+#ifdef __unix__
+    currPrio = 50;
+#endif
+    FixedTimeslotTaskIF* timeslotDemoTask = taskFactory->createFixedTimeslotTask(
+            "PST_TASK", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, deadlineMissedFunc);
+    result = pst::pollingSequenceExamples(timeslotDemoTask);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "InitMission::createTasks: Timeslot demo task initialization failed!" <<
+                std::endl;
+#else
+        sif::printError("InitMission::createTasks: Timeslot demo task initialization failed!\n");
+#endif
+    }
+
+#ifdef __unix__
+    currPrio = 40;
+#endif
+    PeriodicTaskIF* readerTask = taskFactory->createPeriodicTask(
+            "READER_TASK", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, deadlineMissedFunc);
+    result = readerTask->addComponent(objects::TEST_DUMMY_4);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("Dummy 4", objects::TEST_DUMMY_4);
+    }
+#endif /* OBSW_ADD_TASK_EXAMPLE == 1 */
+
+
+#if OBSW_ADD_PUS_STACK == 1
+    /* PUS Services */
+#ifdef __unix__
+    currPrio = 45;
+#endif
+    PeriodicTaskIF* pusVerification = taskFactory->createPeriodicTask(
+            "PUS_VERIF_1", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, deadlineMissedFunc);
+    result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("PUS 1", objects::PUS_SERVICE_1_VERIFICATION);
+    }
+
+#ifdef __unix__
+    currPrio = 50;
+#endif
+    PeriodicTaskIF* pusHighPrio = taskFactory->createPeriodicTask(
+            "PUS_HIGH_PRIO", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, deadlineMissedFunc);
+    result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("PUS 2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+    }
+    result = pusHighPrio->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+    if(result != HasReturnvaluesIF::RETURN_OK){
+        task::printInitError("PUS 5",objects::PUS_SERVICE_5_EVENT_REPORTING);
+    }
+    result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("PUS 9", objects::PUS_SERVICE_9_TIME_MGMT);
+    }
+
+#ifdef __unix__
+    currPrio = 40;
+#endif
+    PeriodicTaskIF* pusMedPrio = taskFactory->createPeriodicTask(
+            "PUS_MED_PRIO", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.6, deadlineMissedFunc);
+    result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("PUS 3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+    }
+    result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("PUS 8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
+    }
+    result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("PUS 20", objects::PUS_SERVICE_20_PARAMETERS);
+    }
+    result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("PUS 200", objects::PUS_SERVICE_200_MODE_MGMT);
+    }
+
+#ifdef __unix__
+    currPrio = 30;
+#endif
+    PeriodicTaskIF* pusLowPrio = taskFactory->createPeriodicTask(
+            "PUS_LOW_PRIO", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.2, deadlineMissedFunc);
+    result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+    if(result!=HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("PUS 17", objects::PUS_SERVICE_17_TEST);
+    }
+#endif /* OBSW_ADD_PUS_STACK == 1 */
+
+#if OBSW_ADD_DEVICE_HANDLER_DEMO == 1
+#ifdef __unix__
+    currPrio = 40;
+#endif
+    FixedTimeslotTaskIF* testDevicesTimeslotTask = taskFactory->createFixedTimeslotTask(
+            "PST_TEST_TASK", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, deadlineMissedFunc);
+    result = pst::pollingSequenceDevices(testDevicesTimeslotTask);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "InitMission::createTasks: Test PST initialization failed!" << std::endl;
+#else
+        sif::printError("InitMission::createTasks: Test PST initialization failed!\n");
+#endif
+    }
+#endif /* OBSW_ADD_DEVICE_HANDLER_DEMO == 1 */
+
+#if OBSW_ADD_CONTROLLER_DEMO == 1
+#ifdef __unix__
+    currPrio = 45;
+#endif
+    PeriodicTaskIF* controllerTask = taskFactory->createPeriodicTask(
+            "TEST_CTRL", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, deadlineMissedFunc);
+    result = controllerTask->addComponent(objects::TEST_CONTROLLER);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("Controller Task", objects::TEST_CONTROLLER);
+    }
+#endif /* OBSW_ADD_CONTROLLER_DEMO == 1 */
+#ifdef __unix__
+    currPrio = 15;
+#endif
+    PeriodicTaskIF* testTask = TaskFactory::instance()->createPeriodicTask(
+            "TEST_TASK", currPrio, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, deadlineMissedFunc);
+    result = testTask->addComponent(objects::TEST_TASK);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        task::printInitError("Test Task", objects::TEST_TASK);
+    }
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "Starting tasks.." << std::endl;
+#else
+    sif::printInfo("Starting tasks..\n");
+#endif
+
+#if OBSW_ADD_CORE_COMPONENTS == 1
+    distributerTask->startTask();
+    udpBridgeTask->startTask();
+    udpPollingTask->startTask();
+    eventTask->startTask();
+#endif /* OBSW_ADD_CORE_COMPONENTS == 1 */
+
+#if OBSW_ADD_PUS_STACK == 1
+    pusVerification->startTask();
+    pusHighPrio->startTask();
+    pusMedPrio->startTask();
+    pusLowPrio->startTask();
+#endif /* OBSW_ADD_PUS_STACK == 1 */
+
+#if OBSW_ADD_TASK_EXAMPLE == 1
+    timeslotDemoTask->startTask();
+    readerTask->startTask();
+#endif /* OBSW_ADD_TASK_EXAMPLE == 1 */
+
+#if OBSW_ADD_DEVICE_HANDLER_DEMO == 1
+    testDevicesTimeslotTask->startTask();
+#endif /* OBSW_ADD_DEVICE_HANDLER_DEMO == 1 */
+
+#if OBSW_ADD_CONTROLLER_DEMO == 1
+    controllerTask->startTask();
+#endif /* OBSW_ADD_CONTROLLER_DEMO == 1 */
+
+    testTask->startTask();
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "Tasks started.." << std::endl;
+#else
+    sif::printInfo("Tasks started..\n");
+#endif
+}
+
+

bsp_hosted/core/InitMission.h

@@ -0,0 +1,10 @@
+#ifndef MISSION_CORE_INITMISSION_H_
+#define MISSION_CORE_INITMISSION_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+
+namespace InitMission {
+void createTasks();
+};
+
+#endif /* MISSION_CORE_INITMISSION_H_ */

bsp_hosted/core/ObjectFactory.cpp

@@ -0,0 +1,59 @@
+#include <OBSWConfig.h>
+
+#include <bsp_hosted/core/ObjectFactory.h>
+#include <bsp_hosted/fsfwconfig/objects/systemObjectList.h>
+#include <bsp_hosted/fsfwconfig/OBSWConfig.h>
+#include <bsp_hosted/fsfwconfig/tmtc/apid.h>
+#include <bsp_hosted/fsfwconfig/tmtc/pusIds.h>
+
+#include <test/TestTask.h>
+
+#include <mission/utility/TmFunnel.h>
+#include <mission/core/GenericFactory.h>
+
+#include <fsfw/monitoring/MonitoringMessageContent.h>
+#include <fsfw/storagemanager/PoolManager.h>
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
+
+#include <fsfw/osal/common/UdpTcPollingTask.h>
+#include <fsfw/osal/common/UdpTmTcBridge.h>
+
+void ObjectFactory::produce(){
+    Factory::setStaticFrameworkObjectIds();
+
+#if OBSW_ADD_CORE_COMPONENTS == 1
+    {
+        LocalPool::LocalPoolConfig poolCfg = {
+                {16, 100}, {32, 50}, {64, 25}, {128,15}, {1024, 5}
+        };
+        new PoolManager(objects::TC_STORE, poolCfg);
+    }
+
+    {
+        LocalPool::LocalPoolConfig poolCfg = {
+                {16, 100}, {32, 50}, {64, 25}, {128,15}, {1024, 5}
+        };
+        new PoolManager(objects::TM_STORE, poolCfg);
+    }
+
+    {
+        LocalPool::LocalPoolConfig poolCfg = {
+                {16, 100}, {32, 50}, {64, 25}, {128,15}, {1024, 5}
+        };
+        new PoolManager(objects::IPC_STORE, poolCfg);
+    }
+
+    /* TMTC Reception via UDP socket */
+    new UdpTmTcBridge(objects::UDP_BRIDGE, objects::CCSDS_DISTRIBUTOR,
+            objects::TM_STORE, objects::TC_STORE);
+    new UdpTcPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
+
+#endif /* OBSW_ADD_CORE_COMPONENTS == 1 */
+
+    new TestTask(objects::TEST_TASK, false);
+
+    ObjectFactory::produceGenericObjects();
+}

bsp_hosted/core/ObjectFactory.h

@@ -0,0 +1,12 @@
+#ifndef MISSION_CORE_OBJECTFACTORY_H_
+#define MISSION_CORE_OBJECTFACTORY_H_
+
+namespace ObjectFactory {
+
+void setStatics();
+void produce();
+
+};
+
+
+#endif /* MISSION_CORE_OBJECTFACTORY_H_ */

bsp_hosted/fsfwconfig/CMakeLists.txt

@@ -0,0 +1,11 @@
+target_sources(${TARGET_NAME} 
+	PRIVATE
+		ipc/missionMessageTypes.cpp
+		pollingsequence/pollingSequenceFactory.cpp
+)
+
+# Add include paths for the executable
+target_include_directories(${TARGET_NAME} 
+	PUBLIC 
+		${CMAKE_CURRENT_SOURCE_DIR}
+)

bsp_hosted/fsfwconfig/FSFWConfig.h

@@ -0,0 +1,72 @@
+#ifndef CONFIG_FSFWCONFIG_H_
+#define CONFIG_FSFWCONFIG_H_
+
+#include <cstddef>
+#include <cstdint>
+
+//! Used to determine whether C++ ostreams are used which can increase
+//! the binary size significantly. If this is disabled,
+//! the C stdio functions can be used alternatively
+#define FSFW_CPP_OSTREAM_ENABLED    1
+
+//! More FSFW related printouts depending on level. Useful for development.
+#define FSFW_VERBOSE_LEVEL          1
+
+//! Can be used to completely disable printouts, even the C stdio ones.
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
+    #define FSFW_DISABLE_PRINTOUT   0
+#endif
+
+#define FSFW_USE_PUS_C_TELEMETRY    1
+
+//! Can be used to disable the ANSI color sequences for C stdio.
+#define FSFW_COLORED_OUTPUT         1
+
+//! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiled source files)
+#define FSFW_OBJ_EVENT_TRANSLATION  0
+
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
+//! Specify whether info events are printed too.
+#define FSFW_DEBUG_INFO             1
+#include "objects/translateObjects.h"
+#include "events/translateEvents.h"
+#else
+#endif
+
+//! When using the newlib nano library, C99 support for stdio facilities
+//! will not be provided. This define should be set to 1 if this is the case.
+#define FSFW_NO_C99_IO              1
+
+//! Specify whether a special mode store is used for Subsystem components.
+#define FSFW_USE_MODESTORE          0
+
+//! Defines if the real time scheduler for linux should be used.
+//! If set to 0, this will also disable priority settings for linux
+//! as most systems will not allow to set nice values without privileges
+//! For embedded linux system set this to 1.
+//! If set to 1 the binary needs "cap_sys_nice=eip" privileges to run
+#define FSFW_USE_REALTIME_FOR_LINUX 0
+
+namespace fsfwconfig {
+
+//! Default timestamp size. The default timestamp will be an seven byte CDC short timestamp.
+static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 7;
+
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simultaneously. This will increase the required RAM for
+//! each CSB service !
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
+
+static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
+
+}
+
+#endif /* CONFIG_FSFWCONFIG_H_ */

bsp_hosted/fsfwconfig/OBSWConfig.h

@@ -0,0 +1,25 @@
+/**
+ * @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>
+
+#ifdef __cplusplus
+
+#include "events/subsystemIdRanges.h"
+#include "objects/systemObjectList.h"
+
+namespace config {
+#endif
+
+/* Add mission configuration flags here */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FSFWCONFIG_OBSWCONFIG_H_ */

bsp_hosted/fsfwconfig/events/subsystemIdRanges.h

@@ -0,0 +1,11 @@
+#ifndef FSFWCONFIG_TMTC_SUBSYSTEMIDRANGES_H_
+#define FSFWCONFIG_TMTC_SUBSYSTEMIDRANGES_H_
+
+#include <commonConfig.h>
+
+namespace SUBSYSTEM_ID {
+enum subsystemId: uint8_t {
+};
+}
+
+#endif /* FSFWCONFIG_TMTC_SUBSYSTEMIDRANGES_H_ */

bsp_hosted/fsfwconfig/fsfwconfig.mk

@@ -0,0 +1,8 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/datapool/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
+
+INCLUDES += $(CURRENTPATH)
+INCLUDES += $(CURRENTPATH)/events

bsp_hosted/fsfwconfig/ipc/missionMessageTypes.cpp

@@ -0,0 +1,11 @@
+#include "missionMessageTypes.h"
+#include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/ipc/CommandMessageCleaner.h>
+
+void messagetypes::clearMissionMessage(CommandMessage* message) {
+	switch((message->getMessageType())) {
+	default:
+		message->setCommand(CommandMessage::CMD_NONE);
+		break;
+	}
+}

bsp_hosted/fsfwconfig/ipc/missionMessageTypes.h

@@ -0,0 +1,19 @@
+#ifndef FSFWCONFIG_IPC_MISSIONMESSAGETYPES_H_
+#define FSFWCONFIG_IPC_MISSIONMESSAGETYPES_H_
+
+#include <fsfw/ipc/FwMessageTypes.h>
+
+class CommandMessage;
+
+namespace messagetypes {
+/* First type must have number MESSAGE_TYPE::FW_MESSAGES_COUNT! */
+/* Remember to add new message types to the clearMissionMessage function below! */
+enum MISSION_MESSAGE_TYPE {
+	COSTUM_MESSAGE = FW_MESSAGES_COUNT,
+};
+
+void clearMissionMessage(CommandMessage* message);
+
+}
+
+#endif /* FSFWCONFIG_IPC_MISSIONMESSAGETYPES_H_ */

bsp_hosted/fsfwconfig/objects/systemObjectList.h

@@ -0,0 +1,16 @@
+#ifndef FSFWCONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+#define FSFWCONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+
+#include <commonSystemObjects.h>
+
+namespace objects {
+enum mission_objects {
+    /* 0x62 ('b') Board and mission specific objects */
+	UDP_BRIDGE = 0x62000300,
+	UDP_POLLING_TASK = 0x62000400,
+	/* Generic name for FSFW static ID setter */
+	DOWNLINK_DESTINATION = UDP_BRIDGE
+};
+}
+
+#endif /* FSFWCONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */

bsp_hosted/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -0,0 +1,5 @@
+/**
+ * Add polling sequence initialization which are not common to every BSP here.
+ */
+#include "pollingSequenceFactory.h"
+

bsp_hosted/fsfwconfig/pollingsequence/pollingSequenceFactory.h

@@ -0,0 +1,14 @@
+#ifndef POLLINGSEQUENCE_POLLINGSEQUENCFACTORY_H_
+#define POLLINGSEQUENCE_POLLINGSEQUENCFACTORY_H_
+
+#include <bsp_hosted/fsfwconfig/OBSWConfig.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+class FixedTimeslotTaskIF;
+
+namespace pst {
+ReturnValue_t pollingSequenceExamples(FixedTimeslotTaskIF *thisSequence);
+ReturnValue_t pollingSequenceDevices(FixedTimeslotTaskIF* thisSequence);
+}
+
+#endif /* POLLINGSEQUENCE_POLLINGSEQUENCFACTORY_H_ */

bsp_hosted/fsfwconfig/returnvalues/classIds.h

@@ -0,0 +1,12 @@
+#ifndef FSFWCONFIG_RETURNVALUES_CLASSIDS_H_
+#define FSFWCONFIG_RETURNVALUES_CLASSIDS_H_
+
+#include <commonConfig.h>
+
+namespace CLASS_ID {
+enum classIds: uint8_t {
+};
+}
+
+
+#endif /* FSFWCONFIG_RETURNVALUES_CLASSIDS_H_ */

bsp_hosted/fsfwconfig/tmtc/apid.h

@@ -0,0 +1,11 @@
+#ifndef FSFWCONFIG_TMTC_APID_H_
+#define FSFWCONFIG_TMTC_APID_H_
+
+#include <cstdint>
+#include <commonConfig.h>
+
+namespace apid {
+static const uint16_t APID = COMMON_APID;
+};
+
+#endif /* FSFWCONFIG_TMTC_APID_H_ */

bsp_hosted/fsfwconfig/tmtc/pusIds.h

@@ -0,0 +1,7 @@
+#ifndef FSFWCONFIG_TMTC_PUSIDS_H_
+#define FSFWCONFIG_TMTC_PUSIDS_H_
+
+#include <commonConfig.h>
+
+
+#endif /* FSFWCONFIG_TMTC_PUSIDS_H_ */

bsp_hosted/main.cpp

@@ -0,0 +1,69 @@
+#include <bsp_hosted/core/InitMission.h>
+#include <bsp_hosted/core/ObjectFactory.h>
+
+#include <test/MutexExample.h>
+#include <common/utility/utility.h>
+#include <mission/utility/PusPacketCreator.h>
+
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tasks/TaskFactory.h>
+
+#include <chrono>
+
+#ifdef WIN32
+static const char* COMPILE_PRINTOUT = "Windows";
+#elif LINUX
+static const char* COMPILE_PRINTOUT = "Linux";
+#else
+static const char* COMPILE_PRINTOUT = "unknown OS";
+#endif
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+ServiceInterfaceStream sif::debug("DEBUG", false);
+ServiceInterfaceStream sif::info("INFO", false);
+ServiceInterfaceStream sif::warning("WARNING", false);
+ServiceInterfaceStream sif::error("ERROR", false, true, true);
+#endif
+
+ObjectManagerIF *objectManager = nullptr;
+
+int main() {
+
+    utility::commonInitPrint("Hosted", COMPILE_PRINTOUT);
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "Producing system objects.." << std::endl;
+#else
+    sif::printInfo("Producing system objects..\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
+	objectManager = new ObjectManager(ObjectFactory::produce);
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "Objects created successfully.." << std::endl;
+    sif::info << "Initializing objects.." << std::endl;
+#else
+    sif::printInfo("Objects created successfully..\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
+	objectManager->initialize();
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "Creating tasks.." << std::endl;
+#else
+    sif::printInfo("Creating tasks..\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
+	InitMission::createTasks();
+
+	MutexExample::example();
+	PusPacketCreator::createPusPacketAndPrint();
+
+	/* Permanent loop. */
+	for(;;) {
+		/* Sleep main thread, not needed anymore. */
+		TaskFactory::delayTask(5000);
+	}
+	return 0;
+}

bsp_hosted/utility/CMakeLists.txt

@@ -0,0 +1,7 @@
+target_sources(${TARGET_NAME} 
+	PUBLIC
+		printChar.c
+)
+
+
+

bsp_hosted/utility/printChar.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+
+void printChar(const char* character, bool errStream) {
+	if(errStream) {
+		fprintf(stderr, "%c", *character);
+	}
+	else {
+		printf("%c", *character);
+	}
+}
+