Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/eive/eive-obsw into mueller/master

bsp_q7s/CMakeLists.txt

@@ -12,6 +12,6 @@ else()
     add_subdirectory(gpio)
     add_subdirectory(core)
     add_subdirectory(memory)
-    add_subdirectory(spiCallbacks)
+    add_subdirectory(callbacks)
     add_subdirectory(devices)
 endif()

bsp_q7s/boardconfig/busConf.h

@@ -44,7 +44,7 @@ static constexpr uint32_t GPIO_MGM_1_RM3100_CS = 16;
 
 static constexpr uint32_t GPIO_MGM_3_RM3100_CS = 10;
 // Active low reset pin
-static constexpr uint32_t GPIO_RESET_GNSS_0 = 8;        // D22
+static constexpr uint32_t GPIO_RESET_GNSS_0 = 9;        // C22
 static constexpr uint32_t GPIO_RESET_GNSS_1 = 12;       // B21
 
 static constexpr uint32_t GPIO_RAD_SENSOR_CS = 19;      // R18

bsp_q7s/callbacks/CMakeLists.txt

@@ -1,3 +1,4 @@
 target_sources(${TARGET_NAME} PRIVATE
 	rwSpiCallback.cpp
+	gnssCallback.cpp
 )

bsp_q7s/callbacks/gnssCallback.cpp

@@ -0,0 +1,26 @@
+#include "gnssCallback.h"
+#include "devices/gpioIds.h"
+
+#include "fsfw/tasks/TaskFactory.h"
+
+ReturnValue_t gps::triggerGpioResetPin(void *args) {
+    ResetArgs* resetArgs = reinterpret_cast<ResetArgs*>(args);
+    if(args == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    if (resetArgs->gpioComIF == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    gpioId_t gpioId;
+    if(resetArgs->gnss1) {
+        gpioId = gpioIds::GNSS_1_NRESET;
+
+    }
+    else {
+        gpioId = gpioIds::GNSS_0_NRESET;
+    }
+    resetArgs->gpioComIF->pullLow(gpioId);
+    TaskFactory::delayTask(resetArgs->waitPeriodMs);
+    resetArgs->gpioComIF->pullHigh(gpioId);
+    return HasReturnvaluesIF::RETURN_OK;
+}

bsp_q7s/callbacks/gnssCallback.h

@@ -0,0 +1,19 @@
+#ifndef BSP_Q7S_CALLBACKS_GNSSCALLBACK_H_
+#define BSP_Q7S_CALLBACKS_GNSSCALLBACK_H_
+
+#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+struct ResetArgs {
+    bool gnss1 = false;
+    LinuxLibgpioIF* gpioComIF = nullptr;
+    uint32_t waitPeriodMs = 100;
+};
+
+namespace gps {
+
+ReturnValue_t triggerGpioResetPin(void* args);
+
+}
+
+#endif /* BSP_Q7S_CALLBACKS_GNSSCALLBACK_H_ */

bsp_q7s/callbacks/rwSpiCallback.cpp

@@ -1,9 +1,10 @@
-#include <bsp_q7s/spiCallbacks/rwSpiCallback.h>
+#include "rwSpiCallback.h"
-#include <fsfw/serviceinterface/ServiceInterface.h>
-#include <mission/devices/RwHandler.h>
-#include <fsfw_hal/linux/spi/SpiCookie.h>
-#include <fsfw_hal/linux/UnixFileGuard.h>
 #include "devices/gpioIds.h"
+#include "mission/devices/RwHandler.h"
+
+#include "fsfw_hal/linux/spi/SpiCookie.h"
+#include "fsfw_hal/linux/UnixFileGuard.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 namespace rwSpiCallback {
 

bsp_q7s/callbacks/rwSpiCallback.h

@@ -1,9 +1,9 @@
 #ifndef BSP_Q7S_RW_SPI_CALLBACK_H_
 #define BSP_Q7S_RW_SPI_CALLBACK_H_
 
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
-#include <fsfw_hal/linux/spi/SpiComIF.h>
+#include "fsfw_hal/linux/spi/SpiComIF.h"
-#include <fsfw_hal/common/gpio/GpioCookie.h>
+#include "fsfw_hal/common/gpio/GpioCookie.h"
 
 
 namespace rwSpiCallback {

bsp_q7s/core/ObjectFactory.cpp

@@ -9,12 +9,13 @@
 #include "devices/powerSwitcherList.h"
 #include "bsp_q7s/gpio/gpioCallbacks.h"
 #include "bsp_q7s/core/CoreController.h"
-#include "bsp_q7s/spiCallbacks/rwSpiCallback.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
 #include "bsp_q7s/memory/FileSystemHandler.h"
 #include "bsp_q7s/devices/PlocSupervisorHandler.h"
 #include "bsp_q7s/devices/PlocUpdater.h"
 #include "bsp_q7s/devices/PlocMemoryDumper.h"
+#include "bsp_q7s/callbacks/rwSpiCallback.h"
+#include "bsp_q7s/callbacks/gnssCallback.h"
 
 #include "linux/devices/HeaterHandler.h"
 #include "linux/devices/SolarArrayDeploymentHandler.h"
@@ -82,6 +83,9 @@
 #include "linux/boardtest/LibgpiodTest.h"
 #endif
 
+ResetArgs resetArgsGnss0;
+ResetArgs resetArgsGnss1;
+
 void ObjectFactory::setStatics() {
     Factory::setStaticFrameworkObjectIds();
 }
@@ -427,6 +431,8 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF *gpioComIF, UartComI
             "GNSS_1_NRESET", gpio::OUT, gpio::HIGH);
     gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_NRESET, gpio);
 
+
+
     // GNSS enable pins must be pulled high
 
     gpioComIF->addGpios(gpioCookieAcsBoard);
@@ -485,6 +491,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF *gpioComIF, UartComI
             objects::SPI_COM_IF, spiCookie);
     gyroL3gHandler->setStartUpImmediately();
 
+    resetArgsGnss1.gnss1 = true;
+    resetArgsGnss1.gpioComIF = gpioComIF;
+    resetArgsGnss1.waitPeriodMs = 100;
+    resetArgsGnss0.gnss1 = false;
+    resetArgsGnss0.gpioComIF = gpioComIF;
+    resetArgsGnss0.waitPeriodMs = 100;
     auto uartCookieGps0 = new UartCookie(objects::GPS0_HANDLER, q7s::UART_GNSS_0_DEV,
             UartModes::CANONICAL, uart::GNSS_BAUD, uart::HYPERION_GPS_REPLY_MAX_BUFFER);
     uartCookieGps0->setToFlushInput(true);
@@ -495,9 +507,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF *gpioComIF, UartComI
     uartCookieGps1->setReadCycles(6);
     auto gpsHandler0 = new GPSHyperionHandler(objects::GPS0_HANDLER, objects::UART_COM_IF,
             uartCookieGps0, true);
+    gpsHandler0->setResetPinTriggerFunction(gps::triggerGpioResetPin, &resetArgsGnss0);
     gpsHandler0->setStartUpImmediately();
     auto gpsHandler1 = new GPSHyperionHandler(objects::GPS1_HANDLER, objects::UART_COM_IF,
             uartCookieGps1, true);
+    gpsHandler1->setResetPinTriggerFunction(gps::triggerGpioResetPin, &resetArgsGnss1);
     gpsHandler1->setStartUpImmediately();
 }
 

fsfw

@@ -1 +1 @@
-Subproject commit 924c150af27484f9eb4439ec80c048b46c226890
+Subproject commit 40adca5f1d13ef8d6c712842ebc37e37fe449446

generators/.gitignore

@@ -0,0 +1 @@
+.~lock*

mission/devices/GPSHyperionHandler.cpp

@@ -6,6 +6,11 @@
 
 #include "lwgps/lwgps.h"
 
+#if FSFW_DEV_HYPERION_GPS_CREATE_NMEA_CSV == 1
+#include <filesystem>
+#include <fstream>
+#endif
+
 GPSHyperionHandler::GPSHyperionHandler(object_id_t objectId, object_id_t deviceCommunication,
         CookieIF *comCookie, bool debugHyperionGps):
         DeviceHandlerBase(objectId, deviceCommunication, comCookie), gpsSet(this),
@@ -47,6 +52,22 @@ ReturnValue_t GPSHyperionHandler::buildNormalDeviceCommand(DeviceCommandId_t *id
 ReturnValue_t GPSHyperionHandler::buildCommandFromCommand(
         DeviceCommandId_t deviceCommand, const uint8_t *commandData,
         size_t commandDataLen) {
+    // By default, send nothing
+    rawPacketLen = 0;
+    switch(deviceCommand) {
+    case(GpsHyperion::TRIGGER_RESET_PIN): {
+        if(resetCallback != nullptr) {
+            PoolReadGuard pg(&gpsSet);
+            // Set HK entries invalid
+            gpsSet.setValidity(false, true);
+            // The user needs to implement this. Don't touch states for now, the device should
+            // quickly reboot and send valid strings again.
+            actionHelper.finish(true, getCommanderQueueId(deviceCommand), deviceCommand);
+            return resetCallback(resetCallbackArgs);
+        }
+        return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
+    }
+    }
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -54,9 +75,9 @@ ReturnValue_t GPSHyperionHandler::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;
+        sif::debug << "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
+            // TODO: Check whether data is valid by checking whether NMEA start string is valid?
             commandExecuted = true;
         }
         int result = lwgps_process(&gpsData, start, len);
@@ -83,7 +104,13 @@ ReturnValue_t GPSHyperionHandler::scanForReply(const uint8_t *start, size_t len,
             gpsSet.latitude.value = gpsData.latitude;
             // Negative longitude -> West direction
             gpsSet.longitude.value = gpsData.longitude;
+            if(gpsData.altitude > 600000.0 or gpsData.altitude < 400000.0) {
+                gpsSet.altitude.setValid(false);
+            }
+            else {
+                gpsSet.altitude.setValid(true);
                 gpsSet.altitude.value = gpsData.altitude;
+            }
             gpsSet.fixMode.value = gpsData.fix_mode;
             gpsSet.satInUse.value = gpsData.sats_in_use;
             Clock::TimeOfDay_t timeStruct = {};
@@ -102,6 +129,7 @@ ReturnValue_t GPSHyperionHandler::scanForReply(const uint8_t *start, size_t len,
             gpsSet.hours = gpsData.hours;
             gpsSet.minutes = gpsData.minutes;
             gpsSet.seconds = gpsData.seconds;
+            gpsSet.unixSeconds = timeval.tv_sec;
             if(debugHyperionGps) {
                 sif::info << "GPS Data" << std::endl;
                 printf("Valid status: %d\n", gpsData.is_valid);
@@ -110,6 +138,13 @@ ReturnValue_t GPSHyperionHandler::scanForReply(const uint8_t *start, size_t len,
                 printf("Altitude: %f meters\n", gpsData.altitude);
             }
 #if FSFW_DEV_HYPERION_GPS_CREATE_NMEA_CSV == 1
+            std::string filename = "/mnt/sd0/gps_log.txt";
+            std::ofstream gpsFile;
+            if(not std::filesystem::exists(filename)) {
+                gpsFile.open(filename, std::ofstream::out);
+            }
+            gpsFile.open(filename, std::ofstream::out | std::ofstream::app);
+            gpsFile.write(reinterpret_cast<const char*>(start), len);
 #endif
         }
         *foundLen = len;
@@ -149,12 +184,19 @@ ReturnValue_t GPSHyperionHandler::initializeLocalDataPool(
 void GPSHyperionHandler::fillCommandAndReplyMap() {
     // Reply length does not matter, packets should always arrive periodically
     insertInReplyMap(GpsHyperion::GPS_REPLY, 4, &gpsSet, 0, true);
+    insertInCommandMap(GpsHyperion::TRIGGER_RESET_PIN);
 }
 
 void GPSHyperionHandler::modeChanged() {
     internalState = InternalStates::NONE;
 }
 
+void GPSHyperionHandler::setResetPinTriggerFunction(gpioResetFunction_t resetCallback,
+        void *args) {
+    this->resetCallback = resetCallback;
+    resetCallbackArgs = args;
+}
+
 void GPSHyperionHandler::debugInterface(uint8_t positionTracker, object_id_t objectId,
         uint32_t parameter) {
 }

mission/devices/GPSHyperionHandler.h

@@ -6,7 +6,6 @@
 #include "devicedefinitions/GPSDefinitions.h"
 #include "lwgps/lwgps.h"
 
-
 /**
  * @brief   Device handler for the Hyperion HT-GPS200 device
  * @details
@@ -15,12 +14,17 @@
  */
 class GPSHyperionHandler: public DeviceHandlerBase {
 public:
+    using gpioResetFunction_t = ReturnValue_t (*) (void* args);
 	GPSHyperionHandler(object_id_t objectId, object_id_t deviceCommunication,
 	        CookieIF* comCookie, bool debugHyperionGps = false);
 	virtual ~GPSHyperionHandler();
 
+	void setResetPinTriggerFunction(gpioResetFunction_t resetCallback, void*args);
 protected:
 
+	gpioResetFunction_t resetCallback = nullptr;
+	void* resetCallbackArgs = nullptr;
+
 	enum class InternalStates {
 	    NONE,
 	    WAIT_FIRST_MESSAGE,

mission/devices/GomspaceDeviceHandler.cpp

@@ -75,6 +75,10 @@ ReturnValue_t GomspaceDeviceHandler::buildCommandFromCommand(
         }
         break;
     }
+    case(GOMSPACE::PRINT_OUT_ENB_STATUS): {
+        result = printStatus(deviceCommand);
+        break;
+    }
     case(GOMSPACE::REQUEST_HK_TABLE): {
         result = generateRequestFullHkTableCmd(hkTableReplySize);
         if(result != HasReturnvaluesIF::RETURN_OK){
@@ -95,6 +99,7 @@ void GomspaceDeviceHandler::fillCommandAndReplyMap(){
     this->insertInCommandAndReplyMap(GOMSPACE::PARAM_GET, 3);
     this->insertInCommandAndReplyMap(GOMSPACE::REQUEST_HK_TABLE, 3);
     this->insertInCommandMap(GOMSPACE::GNDWDT_RESET);
+    this->insertInCommandMap(GOMSPACE::PRINT_OUT_ENB_STATUS);
 }
 
 ReturnValue_t GomspaceDeviceHandler::scanForReply(const uint8_t *start,
@@ -396,3 +401,8 @@ LocalPoolDataSetBase* GomspaceDeviceHandler::getDataSetHandle(sid_t sid) {
 void GomspaceDeviceHandler::setModeNormal() {
     mode = MODE_NORMAL;
 }
+
+ReturnValue_t GomspaceDeviceHandler::printStatus(DeviceCommandId_t cmd) {
+    sif::info << "No printHkTable implementation given.." << std::endl;
+    return HasReturnvaluesIF::RETURN_OK;
+}

mission/devices/GomspaceDeviceHandler.h

@@ -88,6 +88,13 @@ protected:
      */
     virtual ReturnValue_t generateRequestFullHkTableCmd(uint16_t hkTableSize);
 
+    /**
+     * This command handles printing the HK table to the console. This is useful for debugging
+     * purposes
+     * @return
+     */
+    virtual ReturnValue_t printStatus(DeviceCommandId_t cmd);
+
     /**
      * @brief	Because housekeeping tables are device specific the handling of the reply is
      * 			given to the child class.

mission/devices/PDU1Handler.cpp

@@ -1,11 +1,12 @@
+#include <fsfw/datapool/PoolReadGuard.h>
 #include "PDU1Handler.h"
 #include <mission/devices/devicedefinitions/GomSpacePackets.h>
 #include <OBSWConfig.h>
 
 PDU1Handler::PDU1Handler(object_id_t objectId, object_id_t comIF, CookieIF * comCookie) :
         GomspaceDeviceHandler(objectId, comIF, comCookie, PDU::MAX_CONFIGTABLE_ADDRESS,
-                PDU::MAX_HKTABLE_ADDRESS, PDU::HK_TABLE_REPLY_SIZE, &pdu1HkTableDataset), pdu1HkTableDataset(
+                PDU::MAX_HKTABLE_ADDRESS, PDU::HK_TABLE_REPLY_SIZE, &pdu1HkTableDataset),
-                this) {
+        pdu1HkTableDataset(this) {
 }
 
 PDU1Handler::~PDU1Handler() {
@@ -55,25 +56,9 @@ void PDU1Handler::letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *pac
             << std::endl;
     sif::info << "PDU1 channel 8 current: " << pdu1HkTableDataset.currentOutChannel8
             << std::endl;
-    sif::info << "PDU1 TCS Board switch: "
+    printOutputSwitchStates();
-            << static_cast<unsigned int>(pdu1HkTableDataset.outEnabledTCSBoard3V3.value) << std::endl;
+    sif::info << "PDU1 battery mode: " <<
-    sif::info << "PDU1 Syrlinks switch: "
+            static_cast<unsigned int>(pdu1HkTableDataset.battMode.value) << std::endl;
-            << static_cast<unsigned int>(pdu1HkTableDataset.outEnabledSyrlinks.value) << std::endl;
-    sif::info << "PDU1 star tracker switch: "
-            << static_cast<unsigned int>(pdu1HkTableDataset.outEnabledStarTracker.value) << std::endl;
-    sif::info << "PDU1 MGT switch: "
-            << static_cast<unsigned int>(pdu1HkTableDataset.outEnabledMGT.value) << std::endl;
-    sif::info << "PDU1 SUS nominal switch: "
-            << static_cast<unsigned int>(pdu1HkTableDataset.outEnabledSUSNominal.value) << std::endl;
-    sif::info << "PDU1 solar cell experiment switch: "
-            << static_cast<unsigned int>(pdu1HkTableDataset.outEnabledSolarCellExp.value) << std::endl;
-    sif::info << "PDU1 PLOC switch: "
-            << static_cast<unsigned int>(pdu1HkTableDataset.outEnabledPLOC.value) << std::endl;
-    sif::info << "PDU1 ACS Side A switch: "
-            << static_cast<unsigned int>(pdu1HkTableDataset.outEnabledAcsBoardSideA.value) << std::endl;
-    sif::info << "PDU1 channel 8 switch: "
-            << static_cast<unsigned int>(pdu1HkTableDataset.outEnabledChannel8.value) << std::endl;
-    sif::info << "PDU1 battery mode: " << static_cast<unsigned int>(pdu1HkTableDataset.battMode.value) << std::endl;
     sif::info << "PDU1 VCC: " << pdu1HkTableDataset.vcc << " mV" << std::endl;
     float vbat = pdu1HkTableDataset.vbat.value * 0.001;
     sif::info << "PDU1 VBAT: " << vbat << "V" << std::endl;
@@ -87,9 +72,35 @@ void PDU1Handler::letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *pac
 #endif
 }
 
+void PDU1Handler::printOutputSwitchStates() {
+    sif::info << "PDU1 TCS Board switch: " <<
+            static_cast<unsigned int>(pdu1HkTableDataset.outEnabledTCSBoard3V3.value) << std::endl;
+    sif::info << "PDU1 Syrlinks switch: " <<
+            static_cast<unsigned int>(pdu1HkTableDataset.outEnabledSyrlinks.value) << std::endl;
+    sif::info << "PDU1 star tracker switch: " <<
+            static_cast<unsigned int>(pdu1HkTableDataset.outEnabledStarTracker.value) << std::endl;
+    sif::info << "PDU1 MGT switch: " <<
+            static_cast<unsigned int>(pdu1HkTableDataset.outEnabledMGT.value) << std::endl;
+    sif::info << "PDU1 SUS nominal switch: " <<
+            static_cast<unsigned int>(pdu1HkTableDataset.outEnabledSUSNominal.value) << std::endl;
+    sif::info << "PDU1 solar cell experiment switch: " <<
+            static_cast<unsigned int>(pdu1HkTableDataset.outEnabledSolarCellExp.value) << std::endl;
+    sif::info << "PDU1 PLOC switch: " <<
+            static_cast<unsigned int>(pdu1HkTableDataset.outEnabledPLOC.value) << std::endl;
+    sif::info << "PDU1 ACS Side A switch: " <<
+            static_cast<unsigned int>(pdu1HkTableDataset.outEnabledAcsBoardSideA.value) << std::endl;
+    sif::info << "PDU1 channel 8 switch: " <<
+            static_cast<unsigned int>(pdu1HkTableDataset.outEnabledChannel8.value) << std::endl;
+}
+
 void PDU1Handler::parseHkTableReply(const uint8_t *packet) {
     uint16_t dataOffset = 0;
-    pdu1HkTableDataset.read();
+    PoolReadGuard pg(&pdu1HkTableDataset);
+    ReturnValue_t readResult = pg.getReadResult();
+    if(readResult != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "Reading PDU1 HK table failed!" << std::endl;
+        return;
+    }
     /* Fist 10 bytes contain the gomspace header. Each variable is preceded by the 16-bit table
      * address. */
     dataOffset += 12;
@@ -249,8 +260,10 @@ void PDU1Handler::parseHkTableReply(const uint8_t *packet) {
     dataOffset += 3;
     pdu1HkTableDataset.csp2WatchdogPingsLeft = *(packet + dataOffset);
 
-    pdu1HkTableDataset.commit();
     pdu1HkTableDataset.setChanged(true);
+    if(not pdu1HkTableDataset.isValid()) {
+        pdu1HkTableDataset.setValidity(true, true);
+    }
 }
 
 ReturnValue_t PDU1Handler::initializeLocalDataPool(
@@ -341,3 +354,20 @@ ReturnValue_t PDU1Handler::initializeLocalDataPool(
     return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t PDU1Handler::printStatus(DeviceCommandId_t cmd) {
+    switch(cmd) {
+    case(GOMSPACE::PRINT_OUT_ENB_STATUS): {
+        PoolReadGuard pg(&pdu1HkTableDataset);
+        ReturnValue_t readResult = pg.getReadResult();
+        if(readResult != HasReturnvaluesIF::RETURN_OK) {
+            sif::warning << "Reading PDU1 HK table failed!" << std::endl;
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        printOutputSwitchStates();
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+}

mission/devices/PDU1Handler.h

@@ -32,11 +32,13 @@ protected:
      */
     virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) override;
     virtual void letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *packet) override;
+    ReturnValue_t printStatus(DeviceCommandId_t cmd) override;
 
 private:
     /** Dataset for the housekeeping table of the PDU1 */
     PDU1::PDU1HkTableDataset pdu1HkTableDataset;
 
+    void printOutputSwitchStates();
     void parseHkTableReply(const uint8_t *packet);
 };
 

mission/devices/PDU2Handler.cpp

@@ -1,11 +1,13 @@
+#include "OBSWConfig.h"
 #include "PDU2Handler.h"
+
 #include <mission/devices/devicedefinitions/GomSpacePackets.h>
-#include <OBSWConfig.h>
+#include <fsfw/datapool/PoolReadGuard.h>
 
 PDU2Handler::PDU2Handler(object_id_t objectId, object_id_t comIF, CookieIF * comCookie) :
     GomspaceDeviceHandler(objectId, comIF, comCookie, PDU::MAX_CONFIGTABLE_ADDRESS,
-                PDU::MAX_HKTABLE_ADDRESS, PDU::HK_TABLE_REPLY_SIZE, &pdu2HkTableDataset), pdu2HkTableDataset(
+        PDU::MAX_HKTABLE_ADDRESS, PDU::HK_TABLE_REPLY_SIZE, &pdu2HkTableDataset),
-                this) {
+    pdu2HkTableDataset(this) {
 }
 
 PDU2Handler::~PDU2Handler() {
@@ -34,23 +36,7 @@ void PDU2Handler::letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *pac
     sif::info << "PDU2 VBAT: " << vbat << std::endl;
     float temperatureC = pdu2HkTableDataset.temperature.value * 0.1;
     sif::info << "PDU2 Temperature: " << temperatureC << " °C" << std::endl;
-    sif::info << "PDU2 Q7S enable state: " << unsigned(pdu2HkTableDataset.outEnabledQ7S.value) << std::endl;
+    printOutputSwitchStates();
-    sif::info << "PDU2 Payload PCDU channel 1 enable state: "
-            << unsigned(pdu2HkTableDataset.outEnabledPlPCDUCh1.value) << std::endl;
-    sif::info << "PDU2 reaction wheels enable state: "
-            << unsigned(pdu2HkTableDataset.outEnabledReactionWheels.value) << std::endl;
-    sif::info << "PDU2 TCS Board 8V heater input enable state: "
-            << unsigned(pdu2HkTableDataset.outEnabledTCSBoardHeaterIn.value) << std::endl;
-    sif::info << "PDU2 redundant SUS group enable state: "
-            << unsigned(pdu2HkTableDataset.outEnabledSUSRedundant.value) << std::endl;
-    sif::info << "PDU2 deployment mechanism enable state: "
-            << unsigned(pdu2HkTableDataset.outEnabledDeplMechanism.value) << std::endl;
-    sif::info << "PDU2 PCDU channel 6 enable state: "
-            << unsigned(pdu2HkTableDataset.outEnabledPlPCDUCh6.value) << std::endl;
-    sif::info << "PDU2 ACS board side B enable state: "
-            << unsigned(pdu2HkTableDataset.outEnabledAcsBoardSideB.value) << std::endl;
-    sif::info << "PDU2 payload camera enable state: "
-            << unsigned(pdu2HkTableDataset.outEnabledPayloadCamera.value) << std::endl;
     sif::info << "PDU2 uptime: " << pdu2HkTableDataset.uptime << " seconds" << std::endl;
     sif::info << "PDU2 battery mode: " << unsigned(pdu2HkTableDataset.battMode.value) << std::endl;
     sif::info << "PDU2 ground watchdog reboots: " << pdu2HkTableDataset.gndWdtReboots << std::endl;
@@ -323,3 +309,42 @@ ReturnValue_t PDU2Handler::initializeLocalDataPool(
 
     return HasReturnvaluesIF::RETURN_OK;
 }
+
+ReturnValue_t PDU2Handler::printStatus(DeviceCommandId_t cmd) {
+    switch(cmd) {
+    case(GOMSPACE::PRINT_OUT_ENB_STATUS): {
+        PoolReadGuard pg(&pdu2HkTableDataset);
+        ReturnValue_t readResult = pg.getReadResult();
+        if(readResult != HasReturnvaluesIF::RETURN_OK) {
+            sif::warning << "Reading PDU2 HK table failed!" << std::endl;
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        printOutputSwitchStates();
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+}
+
+void PDU2Handler::printOutputSwitchStates() {
+    sif::info << "PDU2 Q7S enable state: " <<
+            unsigned(pdu2HkTableDataset.outEnabledQ7S.value) << std::endl;
+    sif::info << "PDU2 Payload PCDU channel 1 enable state: "
+            << unsigned(pdu2HkTableDataset.outEnabledPlPCDUCh1.value) << std::endl;
+    sif::info << "PDU2 reaction wheels enable state: "
+            << unsigned(pdu2HkTableDataset.outEnabledReactionWheels.value) << std::endl;
+    sif::info << "PDU2 TCS Board 8V heater input enable state: "
+            << unsigned(pdu2HkTableDataset.outEnabledTCSBoardHeaterIn.value) << std::endl;
+    sif::info << "PDU2 redundant SUS group enable state: "
+            << unsigned(pdu2HkTableDataset.outEnabledSUSRedundant.value) << std::endl;
+    sif::info << "PDU2 deployment mechanism enable state: "
+            << unsigned(pdu2HkTableDataset.outEnabledDeplMechanism.value) << std::endl;
+    sif::info << "PDU2 PCDU channel 6 enable state: "
+            << unsigned(pdu2HkTableDataset.outEnabledPlPCDUCh6.value) << std::endl;
+    sif::info << "PDU2 ACS board side B enable state: "
+            << unsigned(pdu2HkTableDataset.outEnabledAcsBoardSideB.value) << std::endl;
+    sif::info << "PDU2 payload camera enable state: "
+            << unsigned(pdu2HkTableDataset.outEnabledPayloadCamera.value) << std::endl;
+}

mission/devices/PDU2Handler.h

@@ -32,12 +32,14 @@ protected:
      */
     virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) override;
     virtual void letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *packet) override;
+    ReturnValue_t printStatus(DeviceCommandId_t cmd) override;
 
 private:
 
     /** Dataset for the housekeeping table of the PDU2 */
     PDU2::PDU2HkTableDataset pdu2HkTableDataset;
 
+    void printOutputSwitchStates();
     void parseHkTableReply(const uint8_t *packet);
 };
 

mission/devices/devicedefinitions/GPSDefinitions.h

@@ -7,6 +7,7 @@
 namespace GpsHyperion {
 
 static constexpr DeviceCommandId_t GPS_REPLY = 0;
+static constexpr DeviceCommandId_t TRIGGER_RESET_PIN = 5;
 
 static constexpr uint32_t DATASET_ID = 0;
 

mission/devices/devicedefinitions/GomspaceDefinitions.h

@@ -26,13 +26,15 @@ namespace GOMSPACE{
 static const uint8_t P60_PORT_GNDWDT_RESET = 9;
 
 /* Device commands are derived from the rparam.h of the gomspace lib */
-    static const DeviceCommandId_t PING = 0x1; //!< [EXPORT] : [COMMAND]
+static const DeviceCommandId_t PING = 1; //!< [EXPORT] : [COMMAND]
-    static const DeviceCommandId_t NONE = 0x2; // Set when no command is pending
+static const DeviceCommandId_t NONE = 2; // Set when no command is pending
-    static const DeviceCommandId_t REBOOT = 0x4; //!< [EXPORT] : [COMMAND]
+static const DeviceCommandId_t REBOOT = 4; //!< [EXPORT] : [COMMAND]
-    static const DeviceCommandId_t GNDWDT_RESET = 0x9; //!< [EXPORT] : [COMMAND]
+static const DeviceCommandId_t GNDWDT_RESET = 9; //!< [EXPORT] : [COMMAND]
-    static const DeviceCommandId_t PARAM_GET = 0x00; //!< [EXPORT] : [COMMAND]
+static const DeviceCommandId_t PARAM_GET = 0; //!< [EXPORT] : [COMMAND]
-    static const DeviceCommandId_t PARAM_SET = 0xFF; //!< [EXPORT] : [COMMAND]
+static const DeviceCommandId_t PARAM_SET = 255; //!< [EXPORT] : [COMMAND]
-    static const DeviceCommandId_t REQUEST_HK_TABLE = 0x10; //!< [EXPORT] : [COMMAND]
+static const DeviceCommandId_t REQUEST_HK_TABLE = 16; //!< [EXPORT] : [COMMAND]
+static const DeviceCommandId_t PRINT_OUT_ENB_STATUS = 17; //!< [EXPORT] : [COMMAND]
+
 }
 
 namespace P60System {