README.md

@@ -40,11 +40,11 @@ the TCF plugin and downloading the cross-compiler as specified in the section be
   
 * Install settings. In the Devices selection, it is sufficient to pick SoC &rarr; Zynq-7000: <br>
 
-<img src="./doc/img/vivado-edition.png" width="50%"> <br>
+<img src="https://egit.irs.uni-stuttgart.de/eive/eive-obsw/src/branch/develop/doc/img/vivado-edition.png" width="50%"> <br>
 
-<img src="./doc/img/vivado-hl-design.png" width="50%"> <br>
+<img src="https://egit.irs.uni-stuttgart.de/eive/eive-obsw/src/branch/develop/doc/img/vivado-hl-design.png" width="50%"> <br>
 
-<img src="./doc/img/xilinx-install.PNG" width="50%"> <br>
+<img src="https://egit.irs.uni-stuttgart.de/eive/eive-obsw/src/branch/develop/doc/img/xilinx-install.PNG" width="50%"> <br>
 
 * For supported OS refer to https://www.xilinx.com/support/documentation/sw_manuals/xilinx2018_2/ug973-vivado-release-notes-install-license.pdf
 * Add path of linux cross-compiler to permanent environment variables (`.profile` file in Linux): 

bsp_linux_board/InitMission.cpp

@@ -135,9 +135,9 @@ void initmission::initTasks() {
     }
 
 #if OBSW_ADD_TEST_PST == 1
-    FixedTimeslotTaskIF* pstTestTask = factory->createFixedTimeslotTask(
+    FixedTimeslotTaskIF* pstTestTask = factory->createFixedTimeslotTask("ACS_PST", 50,
-            "ACS_PST", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
+            PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
-    result = pst::pollingSequenceTest(pstTestTask);
+    result = pst::pstTest(pstTestTask);
     if(result != HasReturnvaluesIF::RETURN_OK) {
         sif::warning << "initmission::initTasks: ACS PST initialization failed!" << std::endl;
     }

bsp_linux_board/ObjectFactory.cpp

@@ -1,3 +1,6 @@
+#include <fsfw_hal/linux/uart/UartComIF.h>
+#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <mission/devices/GPSHandler.h>
 #include "ObjectFactory.h"
 
 #include "objects/systemObjectList.h"
@@ -68,6 +71,8 @@ void ObjectFactory::produce(void* args){
 
 #if RPI_ADD_UART_TEST == 1
     new UartTestClass(objects::UART_TEST);
+#else
+    new UartComIF(objects::UART_COM_IF);
 #endif
 
 #if RPI_LOOPBACK_TEST_GPIO == 1
@@ -146,4 +151,15 @@ void ObjectFactory::produce(void* args){
     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);
+    GPSHandler* gpsHandler = new GPSHandler(objects::GPS0_HANDLER,
+            objects::UART_COM_IF, uartCookie);
+    gpsHandler->setStartUpImmediately();
+#endif
+
 }

bsp_linux_board/boardconfig/rpiConfig.h.in

@@ -7,6 +7,7 @@
 #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

bsp_q7s/InitMission.cpp

@@ -85,14 +85,6 @@ void initmission::initTasks() {
         initmission::printAddObjectError("UDP_POLLING", objects::UDP_POLLING_TASK);
     }
 
-    /* UDP bridge */
-    PeriodicTaskIF* errorReporterTestTask = factory->createPeriodicTask(
-            "ERROR_REPORTER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-    result = udpBridgeTask->addComponent(objects::INTERNAL_ERROR_REPORTER);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
-    }
-
 #if TEST_CCSDS_BRIDGE == 1
     PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask(
             "PTME_TEST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
@@ -153,30 +145,51 @@ void initmission::initTasks() {
     if(result != HasReturnvaluesIF::RETURN_OK) {
         initmission::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
     }
+    result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
+    }
 
 #if TE0720 == 0
-
     //TODO: Add handling of missed deadlines
     /* Polling Sequence Table Default */
 #if Q7S_ADD_SPI_TEST == 0
-    FixedTimeslotTaskIF * pollingSequenceTableTaskDefault = factory->createFixedTimeslotTask(
+    FixedTimeslotTaskIF* spiPst = factory->createFixedTimeslotTask(
-            "PST_TASK_DEFAULT", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0,
+            "PST_TASK_DEFAULT", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0,
             missedDeadlineFunc);
-    result = pst::pollingSequenceInitDefault(pollingSequenceTableTaskDefault);
+    result = pst::pstSpi(spiPst);
     if (result != HasReturnvaluesIF::RETURN_OK) {
         sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
     }
 #endif
 
-    FixedTimeslotTaskIF* gomSpacePstTask = factory->
+    FixedTimeslotTaskIF* uartPst = factory->createFixedTimeslotTask(
-            createFixedTimeslotTask("GS_PST_TASK", 50,
+            "UART_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
-                    PeriodicTaskIF::MINIMUM_STACK_SIZE*8, 1.0, missedDeadlineFunc);
+    result = pst::pstUart(uartPst);
-    result = pst::gomspacePstInit(gomSpacePstTask);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+    }
+    FixedTimeslotTaskIF* gpioPst = factory->createFixedTimeslotTask(
+            "GPIO_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
+    result = pst::pstGpio(gpioPst);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+    }
+    FixedTimeslotTaskIF* i2cPst = factory->createFixedTimeslotTask(
+            "I2C_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
+    result = pst::pstI2c(i2cPst);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+    }
+
+    FixedTimeslotTaskIF* gomSpacePstTask = factory->createFixedTimeslotTask(
+            "GS_PST_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
+    result = pst::pstGompaceCan(gomSpacePstTask);
     if(result != HasReturnvaluesIF::RETURN_OK) {
         sif::error << "InitMission::initTasks: GomSpace PST initialization failed!" << std::endl;
     }
 
-#else
+#else /* TE7020 == 0 */
     FixedTimeslotTaskIF * pollingSequenceTaskTE0720 = factory->createFixedTimeslotTask(
             "PST_TASK_TE0720", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE * 8, 3.0,
             missedDeadlineFunc);
@@ -184,7 +197,7 @@ void initmission::initTasks() {
     if (result != HasReturnvaluesIF::RETURN_OK) {
         sif::error << "InitMission::initTasks: Creating TE0720 PST failed!" << std::endl;
     }
-#endif
+#endif /* TE7020 == 1 */
 
 #if OBSW_ADD_TEST_CODE == 1
     PeriodicTaskIF* testTask = factory->createPeriodicTask(
@@ -213,9 +226,15 @@ void initmission::initTasks() {
     udpBridgeTask->startTask();
     udpPollingTask->startTask();
 
-#if TE0720 == 0 && Q7S_ADD_SPI_TEST == 0
+#if TE0720 == 0
+    uartPst->startTask();
+    gpioPst->startTask();
+    i2cPst->startTask();
+#if Q7S_ADD_SPI_TEST == 0
     gomSpacePstTask->startTask();
-    pollingSequenceTableTaskDefault->startTask();
+    spiPst->startTask();
+#endif /* Q7S_ADD_SPI_TEST == 0 */
+
 #elif TE0720 == 1 && Q7S_ADD_SPI_TEST == 0
     pollingSequenceTaskTE0720->startTask();
 #endif
@@ -226,8 +245,6 @@ void initmission::initTasks() {
     pusMedPrio->startTask();
     pusLowPrio->startTask();
 
-    errorReporterTestTask->startTask();
-
 #if OBSW_ADD_TEST_CODE == 1
     testTask->startTask();
 #endif

bsp_q7s/boardconfig/q7sConfig.h.in

@@ -6,8 +6,8 @@
 /* Only one of those 2 should be enabled! */
 /* Add code for ACS board */
 #define OBSW_ADD_ACS_BOARD              0
+#if OBSW_ADD_ACS_BOARD == 0
 #define Q7S_ADD_SPI_TEST                0
-
+#endif
-
 
 #endif /* BSP_Q7S_BOARDCONFIG_Q7S_CONFIG_H_ */

common/config/commonObjects.h

@@ -48,6 +48,9 @@ enum commonObjects: uint32_t {
     SUS_11 = 0x44000021,
     SUS_12 = 0x44000022,
     SUS_13 = 0x44000023,
+
+    GPS0_HANDLER = 0x44001000,
+    GPS1_HANDLER = 0x44002000
 };
 }
 

fsfw

@@ -1 +1 @@
-Subproject commit cae69d540097acba46bffa47fd7afc6a8a19bd15
+Subproject commit 5f9a6bb155eb59981e7ff851b7efaa1ae25e42b4

fsfw_hal

@@ -1 +1 @@
-Subproject commit fce40ebf9a4a45bafedaee2fc87e5aa10e49fdcc
+Subproject commit 2533af3b53804bc68436236370911e013a2b8f64

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -9,18 +9,40 @@
 #include "objects/systemObjectList.h"
 
 
-ReturnValue_t pst::pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence)
+ReturnValue_t pst::pstGpio(FixedTimeslotTaskIF *thisSequence)
 {
-    /* Length of a communication cycle */
+    // Length of a communication cycle
     uint32_t length = thisSequence->getPeriodMs();
-    thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0,
+
-            DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0,
-            DeviceHandlerIF::PERFORM_OPERATION);
     thisSequence->addSlot(objects::HEATER_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
     thisSequence->addSlot(objects::SOLAR_ARRAY_DEPL_HANDLER, length * 0,
             DeviceHandlerIF::PERFORM_OPERATION);
 
+    // Radiation sensor
+    //    thisSequence->addSlot(objects::RAD_SENSOR, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //    thisSequence->addSlot(objects::RAD_SENSOR, length * 0.2, DeviceHandlerIF::SEND_WRITE);
+    //    thisSequence->addSlot(objects::RAD_SENSOR, length * 0.4, DeviceHandlerIF::GET_WRITE);
+    //    thisSequence->addSlot(objects::RAD_SENSOR, length * 0.6, DeviceHandlerIF::SEND_READ);
+    //    thisSequence->addSlot(objects::RAD_SENSOR, length * 0.8, DeviceHandlerIF::GET_READ);
+    //    if (length != 3000) {
+    //        sif::warning << "pollingSequenceInitDefault: Frequency changed. Make sure timing critical "
+    //                << "SUS sensors still produce correct values" << std::endl;
+    //    }
+    if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    sif::error << "PollingSequence::initialize has errors!" << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
+    uint32_t length = thisSequence->getPeriodMs();
+
+    thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0,
+            DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0,
+            DeviceHandlerIF::PERFORM_OPERATION);
 #if Q7S_ADD_RTD_DEVICES == 1
     thisSequence->addSlot(objects::RTD_IC3, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
     thisSequence->addSlot(objects::RTD_IC4, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
@@ -40,12 +62,8 @@ ReturnValue_t pst::pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence)
     thisSequence->addSlot(objects::RTD_IC18, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
 #endif /* Q7S_ADD_RTD_DEVICES */
 
-    thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::PLOC_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-
     thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_WRITE);
     thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-
 #if Q7S_ADD_RTD_DEVICES == 1
     thisSequence->addSlot(objects::RTD_IC3, length * 0.2, DeviceHandlerIF::SEND_WRITE);
     thisSequence->addSlot(objects::RTD_IC4, length * 0.2, DeviceHandlerIF::SEND_WRITE);
@@ -65,12 +83,8 @@ ReturnValue_t pst::pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence)
     thisSequence->addSlot(objects::RTD_IC18, length * 0.2, DeviceHandlerIF::SEND_WRITE);
 #endif /* Q7S_ADD_RTD_DEVICES */
 
-    thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::PLOC_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-
     thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.4, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.4, DeviceHandlerIF::GET_WRITE);
-
 #if Q7S_ADD_RTD_DEVICES == 1
     thisSequence->addSlot(objects::RTD_IC3, length * 0.4, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::RTD_IC4, length * 0.4, DeviceHandlerIF::GET_WRITE);
@@ -90,12 +104,8 @@ ReturnValue_t pst::pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence)
     thisSequence->addSlot(objects::RTD_IC18, length * 0.4, DeviceHandlerIF::GET_WRITE);
 #endif /* Q7S_ADD_RTD_DEVICES */
 
-    thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::PLOC_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-
     thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.6, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.6, DeviceHandlerIF::SEND_READ);
-
 #if Q7S_ADD_RTD_DEVICES == 1
     thisSequence->addSlot(objects::RTD_IC3, length * 0.6, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::RTD_IC4, length * 0.6, DeviceHandlerIF::SEND_READ);
@@ -115,12 +125,8 @@ ReturnValue_t pst::pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence)
     thisSequence->addSlot(objects::RTD_IC18, length * 0.6, DeviceHandlerIF::SEND_READ);
 #endif /* Q7S_ADD_RTD_DEVICES */
 
-    thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::PLOC_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
-
     thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.8, DeviceHandlerIF::GET_READ);
     thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.8, DeviceHandlerIF::GET_READ);
-
 #if Q7S_ADD_RTD_DEVICES == 1
     thisSequence->addSlot(objects::RTD_IC3, length * 0.8, DeviceHandlerIF::GET_READ);
     thisSequence->addSlot(objects::RTD_IC4, length * 0.8, DeviceHandlerIF::GET_READ);
@@ -139,23 +145,6 @@ ReturnValue_t pst::pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence)
     thisSequence->addSlot(objects::RTD_IC17, length * 0.8, DeviceHandlerIF::GET_READ);
     thisSequence->addSlot(objects::RTD_IC18, length * 0.8, DeviceHandlerIF::GET_READ);
 #endif /* Q7S_ADD_RTD_DEVICES */
-
-    thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
-    thisSequence->addSlot(objects::PLOC_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
-
-
-    /* Radiation sensor */
-//    thisSequence->addSlot(objects::RAD_SENSOR, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-//    thisSequence->addSlot(objects::RAD_SENSOR, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-//    thisSequence->addSlot(objects::RAD_SENSOR, length * 0.4, DeviceHandlerIF::GET_WRITE);
-//    thisSequence->addSlot(objects::RAD_SENSOR, length * 0.6, DeviceHandlerIF::SEND_READ);
-//    thisSequence->addSlot(objects::RAD_SENSOR, length * 0.8, DeviceHandlerIF::GET_READ);
-
-    if (length != 3000) {
-        sif::warning << "pollingSequenceInitDefault: Frequency changed. Make sure timing critical "
-                << "SUS sensors still produce correct values" << std::endl;
-    }
-
     /**
      * The sun sensor will be shutdown as soon as the chip select is pulled high. Thus all
      * requests to a sun sensor must be performed consecutively. Another reason for calling multiple
@@ -412,17 +401,87 @@ ReturnValue_t pst::pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence)
     //    thisSequence->addSlot(objects::SUS_13, length * 0.938, DeviceHandlerIF::SEND_READ);
     //    thisSequence->addSlot(objects::SUS_13, length * 0.938, DeviceHandlerIF::GET_READ);
 
-    if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+    if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "SPI PST initialization failed" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-    sif::error << "PollingSequence::initialize has errors!" << std::endl;
+ReturnValue_t pst::pstI2c(FixedTimeslotTaskIF *thisSequence) {
+    // Length of a communication cycle
+    uint32_t length = thisSequence->getPeriodMs();
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
+    if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "I2C PST initialization failed" << std::endl;
         return HasReturnvaluesIF::RETURN_FAILED;
     }
+    return HasReturnvaluesIF::RETURN_OK;
+}
 
-ReturnValue_t pst::gomspacePstInit(FixedTimeslotTaskIF *thisSequence){
+ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) {
+    // Length of a communication cycle
+    uint32_t length = thisSequence->getPeriodMs();
+    thisSequence->addSlot(objects::PLOC_HANDLER, length * 0,
+            DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0,
+            DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::GPS0_HANDLER, length * 0,
+            DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::GPS1_HANDLER, length * 0,
+            DeviceHandlerIF::PERFORM_OPERATION);
+
+    thisSequence->addSlot(objects::PLOC_HANDLER, length * 0.2,
+            DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.2,
+            DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::GPS0_HANDLER, length * 0.2,
+            DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::GPS1_HANDLER, length * 0.2,
+            DeviceHandlerIF::SEND_WRITE);
+
+    thisSequence->addSlot(objects::PLOC_HANDLER, length * 0.4,
+            DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.4,
+            DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::GPS0_HANDLER, length * 0.4,
+            DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::GPS1_HANDLER, length * 0.4,
+            DeviceHandlerIF::GET_WRITE);
+
+    thisSequence->addSlot(objects::PLOC_HANDLER, length * 0.6,
+            DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.6,
+            DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GPS0_HANDLER, length * 0.6,
+            DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GPS1_HANDLER, length * 0.6,
+            DeviceHandlerIF::SEND_READ);
+
+    thisSequence->addSlot(objects::PLOC_HANDLER, length * 0.8,
+            DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.8,
+            DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::GPS0_HANDLER, length * 0.8,
+            DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::GPS1_HANDLER, length * 0.8,
+            DeviceHandlerIF::GET_READ);
+
+    if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "UART PST initialization failed" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence){
     uint32_t length = thisSequence->getPeriodMs();
 
+    // PCDU handlers receives two messages and both must be handled
     thisSequence->addSlot(objects::PCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
     thisSequence->addSlot(objects::PCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
 
@@ -472,13 +531,13 @@ ReturnValue_t pst::gomspacePstInit(FixedTimeslotTaskIF *thisSequence){
             length * 0.8, DeviceHandlerIF::GET_READ);
 
     if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "Initialization of GomSpace PST failed" << std::endl;
+        sif::error << "GomSpace PST initialization failed" << std::endl;
         return HasReturnvaluesIF::RETURN_FAILED;
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t pst::pollingSequenceTest(FixedTimeslotTaskIF* thisSequence) {
+ReturnValue_t pst::pstTest(FixedTimeslotTaskIF* thisSequence) {
     /* Length of a communication cycle */
     uint32_t length = thisSequence->getPeriodMs();
 #if OBSW_ADD_ACS_BOARD == 1
@@ -560,15 +619,25 @@ ReturnValue_t pst::pollingSequenceTest(FixedTimeslotTaskIF* thisSequence) {
     thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
 #endif
+
+#if RPI_TEST_GPS_HANDLER == 1
+    thisSequence->addSlot(objects::GPS0_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+
+    thisSequence->addSlot(objects::GPS0_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GPS0_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::GPS0_HANDLER, length * 0.5, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GPS0_HANDLER, length * 0.5, DeviceHandlerIF::GET_READ);
+#endif
     static_cast<void>(length);
-    if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+    if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "Test PST initialization failed" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-    sif::error << "PollingSequence::initialize has errors!" << std::endl;
+#if TE7020 == 1
-    return HasReturnvaluesIF::RETURN_FAILED;
-}
-
 ReturnValue_t pst::pollingSequenceTE0720(FixedTimeslotTaskIF *thisSequence) {
     uint32_t length = thisSequence->getPeriodMs();
 
@@ -617,4 +686,4 @@ ReturnValue_t pst::pollingSequenceTE0720(FixedTimeslotTaskIF *thisSequence) {
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
-
+#endif /* TE7020 == 1 */

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.h

@@ -1,7 +1,14 @@
 #ifndef POLLINGSEQUENCEFACTORY_H_
 #define POLLINGSEQUENCEFACTORY_H_
 
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "OBSWConfig.h"
+#if defined(RASPBERRY_PI)
+#include "rpiConfig.h"
+#elif defined(XIPHOS_Q7S)
+#include "q7sConfig.h"
+#endif
+
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 class FixedTimeslotTaskIF;
 
@@ -25,21 +32,36 @@ class FixedTimeslotTaskIF;
 namespace pst {
 
 /* 0.4 second period init*/
-ReturnValue_t pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence);
+ReturnValue_t pstGpio(FixedTimeslotTaskIF *thisSequence);
 
 /**
- * @brief	This function creates the PST for all gomspace devices. They are
+ * @brief	This function creates the PST for all gomspace devices.
- * 			scheduled in a separate PST because the gomspace library uses
+ * @details
- * 			blocking calls when requesting data from devices.
+ * Scheduled in a separate PST because the gomspace library uses blocking calls when requesting
+ * data from devices.
  */
-ReturnValue_t gomspacePstInit(FixedTimeslotTaskIF *thisSequence);
+ReturnValue_t pstGompaceCan(FixedTimeslotTaskIF *thisSequence);
 
-ReturnValue_t pollingSequenceTest(FixedTimeslotTaskIF* thisSequence);
+ReturnValue_t pstUart(FixedTimeslotTaskIF* thisSequence);
 
+ReturnValue_t pstSpi(FixedTimeslotTaskIF* thisSequence);
+
+ReturnValue_t pstI2c(FixedTimeslotTaskIF* thisSequence);
+
+/**
+ * Generic test PST
+ * @param thisSequence
+ * @return
+ */
+ReturnValue_t pstTest(FixedTimeslotTaskIF* thisSequence);
+
+#if TE7020 == 1
 /**
  * @brief   This polling sequence will be created when the software is compiled for the TE0720.
  */
 ReturnValue_t pollingSequenceTE0720(FixedTimeslotTaskIF* thisSequence);
+#endif
+
 }
 
 

mission/devices/GPSHandler.cpp

@@ -49,10 +49,26 @@ ReturnValue_t GPSHandler::buildCommandFromCommand(
 ReturnValue_t GPSHandler::scanForReply(const uint8_t *start, size_t len,
 		DeviceCommandId_t *foundId, size_t *foundLen) {
     // Pass data to GPS library
+    if(len > 0) {
+        sif::info << "GPSHandler::scanForReply: Received " << len << " bytes" << std::endl;
+        if (internalState == InternalStates::WAIT_FIRST_MESSAGE) {
+            // TODO: Check whether data is valid by chcking whether NMEA start string is valid
+            commandExecuted = true;
+        }
         int result = lwgps_process(&gpsData, start, len);
-    if(result != 0) {
+        if(result != 1) {
             sif::warning << "GPSHandler::scanForReply: Issue processing GPS data with lwgps"
                     << std::endl;
+        }
+        else {
+            sif::info << "GPS Data" << std::endl;
+            // Print messages
+            printf("Valid status: %d\n", gpsData.is_valid);
+            printf("Latitude: %f degrees\n", gpsData.latitude);
+            printf("Longitude: %f degrees\n", gpsData.longitude);
+            printf("Altitude: %f meters\n", gpsData.altitude);
+        }
+        *foundLen = len;
     }
 	return HasReturnvaluesIF::RETURN_OK;
 

tmtc

@@ -1 +1 @@
-Subproject commit 20a44b4b67198d42e83a790191ad6740d0aabf7c
+Subproject commit 5be05c2a929dfc908b8de61250e4db890b010fa5