restructured.. a bit

hosted/InitMission.cpp

@@ -0,0 +1,159 @@
+#include <bsp_linux/InitMission.h>
+#include <bsp_linux/ObjectFactory.h>
+
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/datapool/DataPool.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+#include <fsfw/tasks/PeriodicTaskIF.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfwconfig/objects/systemObjectList.h>
+#include <fsfwconfig/OBSWConfig.h>
+
+#include <iostream>
+
+// This is configured for linux without \cr
+#ifdef LINUX
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR", false, false, true);
+#else
+ServiceInterfaceStream sif::debug("DEBUG", true);
+ServiceInterfaceStream sif::info("INFO", true);
+ServiceInterfaceStream sif::warning("WARNING", true);
+ServiceInterfaceStream sif::error("ERROR", true, false, true);
+#endif
+
+ObjectManagerIF *objectManager = nullptr;
+
+//Initialize Data Pool
+DataPool dataPool(nullptr);
+
+void InitMission::initMission() {
+	sif::info << "Building global objects.." << std::endl;
+	/* Instantiate global object manager and also create all objects */
+    objectManager = new ObjectManager(ObjectFactory::produce);
+    sif::info << "Initializing all objects.." << std::endl;
+    objectManager->initialize();
+
+    /* This function creates and starts all tasks */
+    initTasks();
+}
+
+void InitMission::initTasks(){
+	/* TMTC Distribution */
+	PeriodicTaskIF* TmTcDistributor = TaskFactory::instance()->
+			createPeriodicTask("DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE,
+					0.100, nullptr);
+	ReturnValue_t 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;
+    }
+
+    /* UDP bridge */
+    PeriodicTaskIF* UdpBridgeTask = TaskFactory::instance()->createPeriodicTask(
+    		"UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE,
+			0.2, nullptr);
+    result = UdpBridgeTask->addComponent(objects::UDP_BRIDGE);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+    	sif::error << "Add component UDP Unix Bridge failed" << std::endl;
+    }
+    PeriodicTaskIF* UdpPollingTask = TaskFactory::instance()->
+    		createPeriodicTask("UDP_POLLING", 80,
+    		PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, nullptr);
+    result = UdpPollingTask->addComponent(objects::UDP_POLLING_TASK);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+    	sif::error << "Add component UDP Polling failed" << std::endl;
+    }
+
+	/* PUS Services */
+	PeriodicTaskIF* PusVerification = TaskFactory::instance()->
+			createPeriodicTask("PUS_VERIF_1", 40,
+					PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, nullptr);
+	result = PusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+
+	PeriodicTaskIF* PusEvents = TaskFactory::instance()->
+			createPeriodicTask("PUS_VERIF_1", 60,
+					PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, nullptr);
+	result = PusVerification->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+
+	PeriodicTaskIF* PusHighPrio = TaskFactory::instance()->
+			createPeriodicTask("PUS_HIGH_PRIO", 50,
+					PeriodicTaskIF::MINIMUM_STACK_SIZE,
+					0.200, nullptr);
+	result = PusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
+	if(result!=HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+	result = PusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+	if(result!=HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+
+	PeriodicTaskIF* PusMedPrio = TaskFactory::instance()->
+			createPeriodicTask("PUS_HIGH_PRIO", 40,
+					PeriodicTaskIF::MINIMUM_STACK_SIZE,
+					0.8, nullptr);
+	result = PusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
+	if(result!=HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+	result = PusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
+	if(result!=HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+
+	PeriodicTaskIF* PusLowPrio = TaskFactory::instance()->
+			createPeriodicTask("PUSB", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE,
+					1.6, nullptr);
+	result = PusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+	if(result!=HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Object add component failed" << std::endl;
+	}
+
+
+#if OBSW_ADD_TEST_CODE == 1
+	FixedTimeslotTaskIF* TestTimeslotTask = TaskFactory::instance()->
+			createFixedTimeslotTask("PST_TEST_TASK", 10,
+					PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, nullptr);
+	result = pst::pollingSequenceTestFunction(TestTimeslotTask);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "InitMission::createTasks: Test PST initialization "
+				<< "failed!" << std::endl;
+	}
+#endif
+
+	//Main thread sleep
+	sif::info << "Starting tasks.." << std::endl;
+	TmTcDistributor->startTask();
+	UdpBridgeTask->startTask();
+	UdpPollingTask->startTask();
+
+	PusVerification->startTask();
+	PusEvents->startTask();
+	PusHighPrio->startTask();
+	PusMedPrio->startTask();
+	PusLowPrio->startTask();
+#if OBSW_ADD_TEST_CODE == 1
+	TestTimeslotTask->startTask();
+#endif
+	sif::info << "Tasks started.." << std::endl;
+}

hosted/InitMission.h

@@ -0,0 +1,9 @@
+#ifndef BSP_LINUX_INITMISSION_H_
+#define BSP_LINUX_INITMISSION_H_
+
+namespace InitMission {
+void initMission();
+void initTasks();
+};
+
+#endif /* BSP_LINUX_INITMISSION_H_ */

hosted/ObjectFactory.cpp

@@ -0,0 +1,61 @@
+#include "ObjectFactory.h"
+
+#include <fsfwconfig/objects/systemObjectList.h>
+#include <fsfwconfig/OBSWConfig.h>
+#include <fsfwconfig/tmtc/apid.h>
+#include <fsfwconfig/tmtc/pusIds.h>
+
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
+
+#include <mission/core/GenericFactory.h>
+#include <mission/utility/TmFunnel.h>
+
+#ifdef LINUX
+#include <fsfw/osal/linux/TcUnixUdpPollingTask.h>
+#include <fsfw/osal/linux/TmTcUnixUdpBridge.h>
+#elif WIN32
+#include <fsfw/osal/windows/TcWinUdpPollingTask.h>
+#include <fsfw/osal/windows/TmTcWinUdpBridge.h>
+#endif
+
+#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
+
+
+#if OBSW_ADD_TEST_CODE == 1
+#include <test/testtasks/TestTask.h>
+#endif
+
+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::UDP_BRIDGE;
+	// No storage object for now.
+	TmFunnel::storageDestination = objects::NO_OBJECT;
+
+	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+	TmPacketStored::timeStamperId = objects::TIME_STAMPER;
+}
+
+void ObjectFactory::produce(){
+	Factory::setStaticFrameworkObjectIds();
+	ObjectFactory::produceGenericObjects();
+
+#ifdef LINUX
+    new TmTcUnixUdpBridge(objects::UDP_BRIDGE,
+            objects::CCSDS_PACKET_DISTRIBUTOR,
+            objects::TM_STORE, objects::TC_STORE);
+    new TcUnixUdpPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
+#elif WIN32
+    new TmTcWinUdpBridge(objects::UDP_BRIDGE,
+            objects::CCSDS_PACKET_DISTRIBUTOR, objects::TM_STORE,
+            objects::TC_STORE);
+    new TcWinUdpPollingTask(objects::UDP_POLLING_TASK,
+            objects::UDP_BRIDGE);
+#endif
+
+}

hosted/ObjectFactory.h

@@ -0,0 +1,17 @@
+/*
+ * ObjectFactory.h
+ *
+ *  Created on: Sep 22, 2020
+ *      Author: steffen
+ */
+
+#ifndef BSP_LINUX_OBJECTFACTORY_H_
+#define BSP_LINUX_OBJECTFACTORY_H_
+
+
+namespace ObjectFactory {
+	void setStatics();
+	void produce();
+};
+
+#endif /* BSP_LINUX_OBJECTFACTORY_H_ */

hosted/config/version.h

@@ -1,9 +0,0 @@
-#ifndef CONFIG_VERSION_H_
-#define CONFIG_VERSION_H_
-
-#define SW_VERSION 0
-#define SW_SUBVERSION 1
-
-
-
-#endif /* CONFIG_VERSION_H_ */

hosted/fsfwconfig/OBSWVersion.h

@@ -0,0 +1,12 @@
+#ifndef FSFWCONFIG_OBSWVERSION_H_
+#define FSFWCONFIG_OBSWVERSION_H_
+
+const char* const SW_NAME = "eive";
+
+#define SW_VERSION 0
+#define SW_SUBVERSION 2
+#define SW_SUBSUBVERSION 0
+
+
+
+#endif /* FSFWCONFIG_OBSWVERSION_H_ */

hosted/fsfwconfig/ipc/MissionMessageTypes.cpp

@@ -1,5 +1,5 @@
-#include "MissionMessageTypes.h"
 #include <fsfw/ipc/CommandMessage.h>
+#include <hosted/fsfwconfig/ipc/MissionMessageTypes.h>
 
 void messagetypes::clearMissionMessage(CommandMessage* message) {
 	switch(message->getMessageType()) {

hosted/main.cpp

@@ -1,8 +1,8 @@
-#include <mission/core/InitMission.h>
+#include <bsp_linux/InitMission.h>
 #include <fsfw/tasks/TaskFactory.h>
+#include <hosted/fsfwconfig/OBSWVersion.h>
 
 #include <iostream>
-#include <version.h>
 
 #ifdef WIN32
 static const char* COMPILE_PRINTOUT = "Windows";
@@ -20,8 +20,8 @@ int main(void)
 {
     std::cout << "-- EIVE OBSW --" << std::endl;
     std::cout << "-- Compiled for " << COMPILE_PRINTOUT <<  " --" << std::endl;
-    std::cout << "-- Software version v" << SW_VERSION << "." << SW_SUBVERSION
-            << " -- " << std::endl;
+    std::cout << "-- Software version " << SW_NAME << " v" << SW_VERSION << "."
+            << SW_SUBVERSION << "." << SW_SUBSUBVERSION << " -- " << std::endl;
     std::cout << "-- " <<  __DATE__ << " " << __TIME__ << " --" << std::endl;
 
 	InitMission::initMission();