bsp_linux_board/ObjectFactory.cpp

@@ -1,3 +1,4 @@
+#include <devConf.h>
 #include "ObjectFactory.h"
 
 #include "objects/systemObjectList.h"
@@ -6,8 +7,6 @@
 #include "OBSWConfig.h"
 #include "tmtc/apid.h"
 #include "tmtc/pusIds.h"
-#include "spiConf.h"
-
 #include "linux/boardtest/LibgpiodTest.h"
 #include "linux/boardtest/SpiTestClass.h"
 #include "linux/boardtest/UartTestClass.h"

bsp_q7s/boardconfig/busConf.h

@@ -0,0 +1,56 @@
+#ifndef BSP_Q7S_BOARDCONFIG_BUSCONF_H_
+#define BSP_Q7S_BOARDCONFIG_BUSCONF_H_
+
+namespace q7s {
+
+static constexpr char SPI_DEFAULT_DEV[] = "/dev/spidev2.0";
+static constexpr char SPI_RW_DEV[] = "/dev/spidev3.0";
+
+static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c-1";
+
+static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ttyUL3";
+static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ttyUL4";
+static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ttyUL8";
+
+static constexpr char GPIO_ACS_BOARD_DEFAULT_CHIP[] = "gpiochip5";
+static constexpr char GPIO_MGM2_LIS3_CHIP[] = "gpiochip6";
+
+// TODO: Determine new pins, additional ADIS gyro device
+static constexpr uint32_t GPIO_GYRO_0_ADIS_CS = 1;
+static constexpr uint32_t GPIO_GYRO_1_L3G_CS = 7;
+static constexpr uint32_t GPIO_GYRO_2_ADIS_CS = 3;
+static constexpr uint32_t GPIO_GYRO_3_L3G_CS = 3;
+
+static constexpr uint32_t GPIO_MGM_0_LIS3_CS = 5;
+static constexpr uint32_t GPIO_MGM_1_RM3100_CS = 16;
+static constexpr uint32_t GPIO_MGM_2_LIS3_CS = 0;
+static constexpr uint32_t GPIO_MGM_3_RM3100_CS = 10;
+
+static constexpr char GPIO_RW_DEFAULT_CHIP[] = "gpiochip5";
+static constexpr uint32_t GPIO_RW_0_CS = 7;
+static constexpr uint32_t GPIO_RW_1_CS = 3;
+static constexpr uint32_t GPIO_RW_2_CS = 11;
+static constexpr uint32_t GPIO_RW_3_CS = 6;
+
+static constexpr char GPIO_RW_SPI_MUX_CHIP[] = "gpiochip11";
+static constexpr uint32_t GPIO_RW_SPI_MUX_CS = 57;
+
+static constexpr char GPIO_HEATER_CHIP[] = "gpiochip7";
+static constexpr uint32_t GPIO_HEATER_0_PIN = 6;
+static constexpr uint32_t GPIO_HEATER_1_PIN = 12;
+static constexpr uint32_t GPIO_HEATER_2_PIN = 7;
+static constexpr uint32_t GPIO_HEATER_3_PIN = 5;
+static constexpr uint32_t GPIO_HEATER_4_PIN = 3;
+static constexpr uint32_t GPIO_HEATER_5_PIN = 0;
+static constexpr uint32_t GPIO_HEATER_6_PIN = 1;
+static constexpr uint32_t GPIO_HEATER_7_PIN = 11;
+
+static constexpr char GPIO_SOLAR_ARR_DEPL_CHIP[] = "gpiochip7";
+static constexpr uint32_t GPIO_SOL_DEPL_SA_0_PIN = 4;
+static constexpr uint32_t GPIO_SOL_DEPL_SA_1_PIN = 2;
+
+static constexpr char GPIO_RAD_SENSOR_CHIP[] = "gpiochip5";
+static constexpr uint32_t GPIO_RAD_SENSOR_CS = 19;
+}
+
+#endif /* BSP_Q7S_BOARDCONFIG_BUSCONF_H_ */

bsp_q7s/boardtest/Q7STestTask.cpp

@@ -1,3 +1,4 @@
+#include <bsp_q7s/core/CoreController.h>
 #include <bsp_q7s/memory/FileSystemHandler.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 #include "Q7STestTask.h"
@@ -24,6 +25,7 @@ ReturnValue_t Q7STestTask::performOneShotAction() {
     //testScratchApi();
     //testJsonLibDirect();
     //testDummyParams();
+    //testProtHandler();
     //FsOpCodes opCode = FsOpCodes::ATTEMPT_DIR_REMOVAL_NON_EMPTY;
     //testFileSystemHandlerDirect(opCode);
     return TestTask::performOneShotAction();
@@ -131,6 +133,87 @@ void Q7STestTask::testDummyParams() {
     sif::info << "Test value 2 (\"blirb\" expected): " << test2 << std::endl;
 }
 
+ReturnValue_t Q7STestTask::initialize() {
+    coreController = ObjectManager::instance()->get<CoreController>(objects::CORE_CONTROLLER);
+    if(coreController == nullptr) {
+        sif::warning << "Q7STestTask::initialize: Could not retrieve CORE_CONTROLLER object" <<
+                std::endl;
+    }
+    return TestTask::initialize();
+}
+
+void Q7STestTask::testProtHandler() {
+    bool opPerformed = false;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    // If any chips are unlocked, lock them here
+    result = coreController->setBootCopyProtection(
+            CoreController::Chip::ALL_CHIP, CoreController::Copy::ALL_COPY, true,
+            opPerformed, true);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+         sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
+    }
+
+    // unlock own copy
+    result = coreController->setBootCopyProtection(
+            CoreController::Chip::SELF_CHIP, CoreController::Copy::SELF_COPY, false,
+            opPerformed, true);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
+    }
+    if(not opPerformed) {
+        sif::warning << "Q7STestTask::testProtHandler: No op performed" << std::endl;
+    }
+    int retval = std::system("print-chip-prot-status.sh");
+    if(retval != 0) {
+        utility::handleSystemError(retval, "Q7STestTask::testProtHandler");
+    }
+
+    // lock own copy
+    result = coreController->setBootCopyProtection(
+            CoreController::Chip::SELF_CHIP, CoreController::Copy::SELF_COPY, true,
+            opPerformed, true);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
+    }
+    if(not opPerformed) {
+        sif::warning << "Q7STestTask::testProtHandler: No op performed" << std::endl;
+    }
+    retval = std::system("print-chip-prot-status.sh");
+    if(retval != 0) {
+        utility::handleSystemError(retval, "Q7STestTask::testProtHandler");
+    }
+
+    // unlock specific copy
+    result = coreController->setBootCopyProtection(
+            CoreController::Chip::CHIP_1, CoreController::Copy::COPY_1, false,
+            opPerformed, true);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
+    }
+    if(not opPerformed) {
+        sif::warning << "Q7STestTask::testProtHandler: No op performed" << std::endl;
+    }
+    retval = std::system("print-chip-prot-status.sh");
+    if(retval != 0) {
+        utility::handleSystemError(retval, "Q7STestTask::testProtHandler");
+    }
+
+    // lock specific copy
+    result = coreController->setBootCopyProtection(
+            CoreController::Chip::CHIP_1, CoreController::Copy::COPY_1, true,
+            opPerformed, true);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
+    }
+    if(not opPerformed) {
+        sif::warning << "Q7STestTask::testProtHandler: No op performed" << std::endl;
+    }
+    retval = std::system("print-chip-prot-status.sh");
+    if(retval != 0) {
+        utility::handleSystemError(retval, "Q7STestTask::testProtHandler");
+    }
+}
+
 void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
     auto fsHandler = ObjectManager::instance()->
             get<FileSystemHandler>(objects::FILE_SYSTEM_HANDLER);

bsp_q7s/boardtest/Q7STestTask.h

@@ -6,7 +6,10 @@
 class Q7STestTask: public TestTask {
 public:
     Q7STestTask(object_id_t objectId);
+
+    ReturnValue_t initialize() override;
 private:
+    CoreController* coreController = nullptr;
     ReturnValue_t performOneShotAction() override;
 
     void testSdCard();
@@ -15,6 +18,7 @@ private:
     void testScratchApi();
     void testJsonLibDirect();
     void testDummyParams();
+    void testProtHandler();
 
     enum FsOpCodes {
         CREATE_EMPTY_FILE_IN_TMP,

bsp_q7s/core/CoreController.cpp

@@ -21,12 +21,11 @@
 
 #include <filesystem>
 
-CoreController::Chip CoreController::currentChip = Chip::NO_CHIP;
+CoreController::Chip CoreController::CURRENT_CHIP = Chip::NO_CHIP;
-CoreController::Copy CoreController::currentCopy = Copy::NO_COPY;
+CoreController::Copy CoreController::CURRENT_COPY = Copy::NO_COPY;
 
 CoreController::CoreController(object_id_t objectId):
-        ExtendedControllerBase(objectId, objects::NO_OBJECT, 5),
+        ExtendedControllerBase(objectId, objects::NO_OBJECT, 5), opDivider(5) {
-        opDivider(5) {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     try {
         result = initWatchdogFifo();
@@ -86,6 +85,28 @@ ReturnValue_t CoreController::initialize() {
     return ExtendedControllerBase::initialize();
 }
 
+ReturnValue_t CoreController::initializeAfterTaskCreation() {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    if(BLOCKING_SD_INIT) {
+        ReturnValue_t result = initSdCardBlocking();
+        if(result != HasReturnvaluesIF::RETURN_OK and result != SdCardManager::ALREADY_MOUNTED) {
+            sif::warning << "CoreController::CoreController: SD card init failed" << std::endl;
+        }
+    }
+    sdStateMachine();
+    result = initVersionFile();
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "CoreController::initialize: Version initialization failed" << std::endl;
+    }
+    // Add script folder to path
+    char* currentEnvPath = getenv("PATH");
+    std::string updatedEnvPath = std::string(currentEnvPath) + ":/home/root/scripts";
+    setenv("PATH", updatedEnvPath.c_str(), true);
+    updateProtInfo();
+    initPrint();
+    return result;
+}
+
 ReturnValue_t CoreController::checkModeCommand(Mode_t mode, Submode_t submode,
         uint32_t *msToReachTheMode) {
     return HasReturnvaluesIF::RETURN_OK;
@@ -539,23 +560,6 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
     }
 }
 
-ReturnValue_t CoreController::initializeAfterTaskCreation() {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    if(BLOCKING_SD_INIT) {
-        ReturnValue_t result = initSdCardBlocking();
-        if(result != HasReturnvaluesIF::RETURN_OK and result != SdCardManager::ALREADY_MOUNTED) {
-            sif::warning << "CoreController::CoreController: SD card init failed" << std::endl;
-        }
-    }
-    sdStateMachine();
-    result = initVersionFile();
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::warning << "CoreController::initialize: Version initialization failed" << std::endl;
-    }
-    initPrint();
-    return result;
-}
-
 ReturnValue_t CoreController::sdColdRedundantBlockingInit() {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
@@ -614,7 +618,7 @@ ReturnValue_t CoreController::initVersionFile() {
             std::to_string(FSFW_SUBVERSION) + "." + std::to_string(FSFW_REVISION);
     std::string systemString = "System: " + unameLine;
     std::string mountPrefix = SdCardManager::instance()->getCurrentMountPrefix();
-    std::string versionFilePath = mountPrefix + "/conf/version.txt";
+    std::string versionFilePath = mountPrefix + VERSION_FILE;
     std::fstream versionFile;
 
     if(not std::filesystem::exists(versionFilePath)) {
@@ -731,32 +735,31 @@ ReturnValue_t CoreController::actionListDirectoryIntoFile(ActionId_t actionId,
 }
 
 ReturnValue_t CoreController::initBootCopy() {
-    std::string fileName = "/tmp/curr_copy.txt";
+    if(not std::filesystem::exists(CURR_COPY_FILE)) {
-    if(not std::filesystem::exists(fileName)) {
         // Thils file is created by the systemd service eive-early-config so this should
         // not happen normally
-        std::string cmd = "xsc_boot_copy > " + fileName;
+        std::string cmd = "xsc_boot_copy > " + std::string(CURR_COPY_FILE);
         int result = std::system(cmd.c_str());
         if(result != 0) {
             utility::handleSystemError(result, "CoreController::initBootCopy");
         }
     }
-    std::ifstream file(fileName);
+    std::ifstream file(CURR_COPY_FILE);
     std::string line;
     std::getline(file, line);
     std::istringstream iss(line);
     int value = 0;
     iss >> value;
-    currentChip = static_cast<Chip>(value);
+    CURRENT_CHIP = static_cast<Chip>(value);
     iss >> value;
-    currentCopy = static_cast<Copy>(value);
+    CURRENT_COPY = static_cast<Copy>(value);
     return HasReturnvaluesIF::RETURN_OK;
 }
 
 void CoreController::getCurrentBootCopy(Chip &chip, Copy &copy) {
     // Not really thread-safe but it does not need to be
-    chip = currentChip;
+    chip = CURRENT_CHIP;
-    copy = currentCopy;
+    copy = CURRENT_COPY;
 }
 
 ReturnValue_t CoreController::initWatchdogFifo() {
@@ -795,6 +798,7 @@ ReturnValue_t CoreController::actionPerformReboot(const uint8_t *data, size_t si
         return HasActionsIF::INVALID_PARAMETERS;
     }
     bool rebootSameBootCopy = data[0];
+    bool protOpPerformed;
     if(rebootSameBootCopy) {
 #if OBSW_VERBOSE_LEVEL >= 1
         sif::info << "CoreController::actionPerformReboot: Rebooting on current image" << std::endl;
@@ -802,6 +806,12 @@ ReturnValue_t CoreController::actionPerformReboot(const uint8_t *data, size_t si
         // Attempt graceful shutdown by unmounting and switching off SD cards
         SdCardManager::instance()->switchOffSdCard(sd::SdCard::SLOT_0);
         SdCardManager::instance()->switchOffSdCard(sd::SdCard::SLOT_1);
+        // If any boot copies are unprotected
+        ReturnValue_t retval = setBootCopyProtection(Chip::SELF_CHIP, Copy::SELF_COPY,
+                true, protOpPerformed, false);
+        if(retval == HasReturnvaluesIF::RETURN_OK and protOpPerformed) {
+            sif::info << "Running slot was writeprotected before reboot" << std::endl;
+        }
         int result = std::system("xsc_boot_copy -r");
         if(result != 0) {
             utility::handleSystemError(result, "CoreController::executeAction");
@@ -816,6 +826,16 @@ ReturnValue_t CoreController::actionPerformReboot(const uint8_t *data, size_t si
     sif::info << "CoreController::actionPerformReboot: Rebooting on " <<
             static_cast<int>(data[1]) << " " << static_cast<int>(data[2]) << std::endl;
 #endif
+
+    // Check that the target chip and copy is writeprotected first
+    generateChipStateFile();
+    // If any boot copies are unprotected, protect them here
+    ReturnValue_t retval = setBootCopyProtection(static_cast<Chip>(data[1]),
+            static_cast<Copy>(data[2]), true, protOpPerformed, false);
+    if(retval == HasReturnvaluesIF::RETURN_OK and protOpPerformed) {
+        sif::info << "Target slot was writeprotected before reboot" << std::endl;
+    }
+
     // The second byte in data is the target chip, the third byte is the target copy
     std::string cmdString = "xsc_boot_copy " + std::to_string(data[1]) + " " +
             std::to_string(data[2]);
@@ -873,6 +893,250 @@ bool CoreController::sdInitFinished() const {
     return sdInfo.initFinished;
 }
 
+ReturnValue_t CoreController::generateChipStateFile() {
+    int result = std::system(CHIP_PROT_SCRIPT);
+    if(result != 0) {
+        utility::handleSystemError(result, "CoreController::generateChipStateFile");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CoreController::setBootCopyProtection(Chip targetChip, Copy targetCopy,
+        bool protect, bool& protOperationPerformed, bool updateProtFile) {
+    bool allChips = false;
+    bool allCopies = false;
+    bool selfChip = false;
+    bool selfCopy = false;
+    protOperationPerformed = false;
+
+    switch(targetChip) {
+    case(Chip::ALL_CHIP): {
+        allChips = true;
+        break;
+    }
+    case(Chip::NO_CHIP): {
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(Chip::SELF_CHIP): {
+        selfChip = true;
+        targetChip = CURRENT_CHIP;
+        break;
+    }
+    default: {
+        break;
+    }
+    }
+    switch(targetCopy) {
+    case(Copy::ALL_COPY): {
+        allCopies = true;
+        break;
+    }
+    case(Copy::NO_COPY): {
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(Copy::SELF_COPY): {
+        selfCopy = true;
+        targetCopy = CURRENT_COPY;
+        break;
+    }
+    default: {
+        break;
+    }
+    }
+
+    for(uint8_t arrIdx = 0; arrIdx < protArray.size(); arrIdx++) {
+        int result = handleBootCopyProtAtIndex(targetChip, targetCopy, protect,
+                protOperationPerformed, selfChip, selfCopy, allChips, allCopies, arrIdx);
+        if(result != 0) {
+            break;
+        }
+    }
+    if(protOperationPerformed and updateProtFile) {
+        updateProtInfo();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+int CoreController::handleBootCopyProtAtIndex(Chip targetChip, Copy targetCopy, bool protect,
+    bool &protOperationPerformed, bool selfChip, bool selfCopy, bool allChips,
+    bool allCopies, uint8_t arrIdx) {
+    bool currentProt = protArray[arrIdx];
+    std::ostringstream oss;
+    bool performOp = false;
+    if(protect == currentProt) {
+        return 0;
+    }
+    if(protOperationPerformed) {
+        if((selfChip and selfCopy) or (not allCopies and not allChips)) {
+            // No need to continue, only one operation was requested
+            return 1;
+        }
+    }
+    Chip currentChip;
+    Copy currentCopy;
+    oss << "writeprotect ";
+    if(arrIdx == 0 or arrIdx == 1) {
+        oss << "0 ";
+        currentChip = Chip::CHIP_0;
+    }
+    else {
+        oss << "1 ";
+        currentChip = Chip::CHIP_1;
+    }
+    if(arrIdx == 0 or arrIdx == 2) {
+        oss << "0 ";
+        currentCopy = Copy::COPY_0;
+    }
+    else {
+        oss << "1 ";
+        currentCopy = Copy::COPY_1;
+    }
+    if(protect) {
+        oss << "1";
+    }
+    else {
+        oss << "0";
+    }
+
+    int result = 0;
+    if(allChips and allCopies) {
+        performOp = true;
+    }
+    else if(allChips) {
+        if((selfCopy and CURRENT_COPY == targetCopy) or
+                (currentCopy == targetCopy)) {
+            performOp = true;
+        }
+    }
+    else if(allCopies) {
+        if((selfChip and CURRENT_COPY == targetCopy) or
+                (currentChip == targetChip)) {
+            performOp = true;
+        }
+    }
+    else if(selfChip and (currentChip == targetChip)) {
+        if(selfCopy) {
+            if(currentCopy == targetCopy) {
+                performOp = true;
+            }
+        }
+        else {
+            performOp = true;
+        }
+
+    }
+    else if(selfCopy and (currentCopy == targetCopy)) {
+        if(selfChip) {
+            if(currentChip == targetChip) {
+                performOp = true;
+            }
+        }
+        else {
+            performOp = true;
+        }
+    }
+    else if((targetChip == currentChip) and (targetCopy == currentCopy)) {
+        performOp = true;
+    }
+    if(result != 0) {
+        utility::handleSystemError(result, "CoreController::checkAndSetBootCopyProtection");
+    }
+    if(performOp) {
+        // TODO: Lock operation take a long time. Use command executor? That would require a
+        // new state machine..
+        protOperationPerformed = true;
+        sif::info << "Executing command: " << oss.str() << std::endl;
+        result = std::system(oss.str().c_str());
+    }
+    return 0;
+}
+
+ReturnValue_t CoreController::updateProtInfo(bool regenerateChipStateFile) {
+    using namespace std;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    if(regenerateChipStateFile) {
+        result = generateChipStateFile();
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            sif::warning << "CoreController::updateProtInfo: Generating chip state file failed" <<
+                    std::endl;
+            return result;
+        }
+    }
+    if(not filesystem::exists(CHIP_STATE_FILE)) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    ifstream chipStateFile(CHIP_STATE_FILE);
+    if(not chipStateFile.good()) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    string nextLine;
+    uint8_t lineCounter = 0;
+    string word;
+    while(getline(chipStateFile, nextLine)) {
+        ReturnValue_t result = handleProtInfoUpdateLine(nextLine);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            sif::warning << "CoreController::updateProtInfo: Protection info update failed!" <<
+                    std::endl;
+            return result;
+        }
+        ++lineCounter;
+        if(lineCounter > 4) {
+            sif::warning << "CoreController::checkAndProtectBootCopy: "
+                    "Line counter larger than 4" << std::endl;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CoreController::handleProtInfoUpdateLine(std::string nextLine) {
+    using namespace std;
+    string word;
+    uint8_t wordIdx = 0;
+    uint8_t arrayIdx = 0;
+    istringstream iss(nextLine);
+    Chip currentChip;
+    Copy currentCopy;
+    while(iss >> word) {
+        if(wordIdx == 1) {
+            currentChip = static_cast<Chip>(stoi(word));
+        }
+        if(wordIdx == 3) {
+            currentCopy = static_cast<Copy>(stoi(word));
+        }
+
+        if(wordIdx == 3) {
+            if(currentChip == Chip::CHIP_0) {
+                if(currentCopy == Copy::COPY_0) {
+                    arrayIdx = 0;
+                }
+                else if(currentCopy == Copy::COPY_1) {
+                    arrayIdx = 1;
+                }
+            }
+
+            else if(currentChip == Chip::CHIP_1) {
+               if(currentCopy == Copy::COPY_0) {
+                   arrayIdx = 2;
+               }
+               else if(currentCopy == Copy::COPY_1) {
+                   arrayIdx = 3;
+               }
+           }
+        }
+        if(wordIdx == 5) {
+            if(word == "unlocked.") {
+                protArray[arrayIdx] = false;
+            }
+            else {
+                protArray[arrayIdx] = true;
+            }
+        }
+        wordIdx++;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 void CoreController::performWatchdogControlOperation() {
     // Only perform each fifth iteration
     if(watchdogFifoFd != 0 and opDivider.checkAndIncrement()) {

bsp_q7s/core/CoreController.h

@@ -16,17 +16,28 @@ public:
     enum Chip: uint8_t {
         CHIP_0,
         CHIP_1,
-        NO_CHIP
+        NO_CHIP,
+        SELF_CHIP,
+        ALL_CHIP
     };
 
     enum Copy: uint8_t {
         COPY_0,
         COPY_1,
-        NO_COPY
+        NO_COPY,
+        SELF_COPY,
+        ALL_COPY
     };
 
+    static constexpr char CHIP_PROT_SCRIPT[] = "/home/root/scripts/get-chip-prot-status.sh";
+    static constexpr char CHIP_STATE_FILE[] = "/tmp/chip_prot_status.txt";
+    static constexpr char CURR_COPY_FILE[] = "/tmp/curr_copy.txt";
+    static constexpr char VERSION_FILE[] = "/conf/sd_status";
+
     static constexpr ActionId_t LIST_DIRECTORY_INTO_FILE = 0;
     static constexpr ActionId_t REBOOT_OBC = 32;
+    static constexpr ActionId_t MOUNT_OTHER_COPY = 33;
+
 
     static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CORE;
 
@@ -46,19 +57,39 @@ public:
     ReturnValue_t handleCommandMessage(CommandMessage *message) override;
     void performControlOperation() override;
 
+    /**
+     * Generate a file containing the chip lock/unlock states inside /tmp/chip_prot_status.txt
+     * @return
+     */
+    static ReturnValue_t generateChipStateFile();
     static ReturnValue_t incrementAllocationFailureCount();
     static void getCurrentBootCopy(Chip& chip, Copy& copy);
+
+    ReturnValue_t updateProtInfo(bool regenerateChipStateFile = true);
+
+    /**
+     * Checks whether the target chip and copy are write protected and protect set them to a target
+     * state where applicable.
+     * @param targetChip
+     * @param targetCopy
+     * @param protect       Target state
+     * @param protOperationPerformed [out] Can be used to determine whether any operation
+     * was performed
+     * @param updateProtFile Specify whether the protection info file is updated
+     * @return
+     */
+    ReturnValue_t setBootCopyProtection(Chip targetChip, Copy targetCopy,
+            bool protect, bool& protOperationPerformed, bool updateProtFile = true);
+
     bool sdInitFinished() const;
 
 private:
-    static Chip currentChip;
+    static Chip CURRENT_CHIP;
-    static Copy currentCopy;
+    static Copy CURRENT_COPY;
 
-    ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+    // Designated value for rechecking FIFO open
-            LocalDataPoolManager& poolManager) override;
+    static constexpr int RETRY_FIFO_OPEN = -2;
-    LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+    int watchdogFifoFd = 0;
-    ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                uint32_t *msToReachTheMode);
 
     // States for SD state machine, which is used in non-blocking mode
     enum class SdStates {
@@ -85,9 +116,6 @@ private:
 
     SdCardManager* sdcMan = nullptr;
 
-    ReturnValue_t initSdCardBlocking();
-    ReturnValue_t sdStateMachine();
-
     struct SdInfo {
         sd::SdCard pref = sd::SdCard::NONE;
         sd::SdState prefState = sd::SdState::OFF;
@@ -108,9 +136,30 @@ private:
         sd::SdCard commandedCard = sd::SdCard::NONE;
         sd::SdState commandedState = sd::SdState::OFF;
     };
-
     SdInfo sdInfo;
 
+    /**
+     * Index 0: Chip 0 Copy 0
+     * Index 1: Chip 0 Copy 1
+     * Index 2: Chip 1 Copy 0
+     * Index 3: Chip 1 Copy 1
+     */
+    std::array<bool, 4> protArray;
+    PeriodicOperationDivider opDivider;
+
+    ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override;
+    LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+    ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                uint32_t *msToReachTheMode);
+
+    ReturnValue_t initVersionFile();
+    ReturnValue_t initBootCopy();
+    ReturnValue_t initWatchdogFifo();
+    ReturnValue_t initSdCardBlocking();
+    void initPrint();
+
+    ReturnValue_t sdStateMachine();
     void updateSdInfoOther();
     ReturnValue_t sdCardSetup(sd::SdCard sdCard, sd::SdState targetState, std::string sdChar,
             bool printOutput = true);
@@ -120,24 +169,16 @@ private:
     void executeNextExternalSdCommand();
     void checkExternalSdCommandStatus();
 
-    ReturnValue_t initVersionFile();
-    ReturnValue_t initBootCopy();
-    ReturnValue_t initWatchdogFifo();
-
     ReturnValue_t actionListDirectoryIntoFile(ActionId_t actionId, MessageQueueId_t commandedBy,
             const uint8_t *data, size_t size);
     ReturnValue_t actionPerformReboot(const uint8_t *data, size_t size);
 
-    void initPrint();
-
-    // Designated value for rechecking FIFO open
-    static constexpr int RETRY_FIFO_OPEN = -2;
-    int watchdogFifoFd = 0;
-
-    PeriodicOperationDivider opDivider;
     void performWatchdogControlOperation();
+
+    ReturnValue_t handleProtInfoUpdateLine(std::string nextLine);
+    int handleBootCopyProtAtIndex(Chip targetChip, Copy targetCopy, bool protect,
+            bool &protOperationPerformed, bool selfChip, bool selfCopy, bool allChips,
+            bool allCopies, uint8_t arrIdx);
 };
 
-
-
 #endif /* BSP_Q7S_CORE_CORECONTROLLER_H_ */

bsp_q7s/core/InitMission.cpp

@@ -114,7 +114,7 @@ void initmission::initTasks() {
     }
 #endif /* BOARD_TE0720 */
 
-#if TEST_CCSDS_BRIDGE == 1
+#if OBSW_TEST_CCSDS_BRIDGE == 1
     PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask(
             "PTME_TEST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
     result = ptmeTestTask->addComponent(objects::CCSDS_IP_CORE_BRIDGE);
@@ -127,8 +127,11 @@ void initmission::initTasks() {
     createPusTasks(*factory, missedDeadlineFunc, pusTasks);
     std::vector<PeriodicTaskIF*> pstTasks;
     createPstTasks(*factory, missedDeadlineFunc, pstTasks);
+
+#if OBSW_ADD_TEST_TASK == 1
     std::vector<PeriodicTaskIF*> testTasks;
     createTestTasks(*factory, missedDeadlineFunc, testTasks);
+#endif
 
     auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
         for(const auto& task: taskVector) {
@@ -152,11 +155,11 @@ void initmission::initTasks() {
 
     taskStarter(pstTasks, "PST task vector");
     taskStarter(pusTasks, "PUS task vector");
-#if OBSW_ADD_TEST_CODE == 1
+#if OBSW_ADD_TEST_TASK == 1
     taskStarter(testTasks, "Test task vector");
 #endif
 
-#if TEST_CCSDS_BRIDGE == 1
+#if OBSW_TEST_CCSDS_BRIDGE == 1
     ptmeTestTask->startTask();
 #endif
 
@@ -308,11 +311,11 @@ void initmission::createTestTasks(TaskFactory& factory, TaskDeadlineMissedFuncti
         initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
     }
 #endif
-#if BOARD_TE0720 == 1 && TEST_LIBGPIOD == 1
+#if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1
     result = testTask->addComponent(objects::LIBGPIOD_TEST);
     if(result != HasReturnvaluesIF::RETURN_OK) {
         initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
     }
-#endif /* BOARD_TE0720 == 1 && TEST_LIBGPIOD == 1 */
+#endif /* BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1 */
     taskVec.push_back(testTask);
 }

bsp_q7s/core/ObjectFactory.cpp

@@ -1,12 +1,12 @@
 #include "ObjectFactory.h"
 #include "OBSWConfig.h"
+#include "devConf.h"
+#include "busConf.h"
 #include "tmtc/apid.h"
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
 #include "tmtc/pusIds.h"
 #include "devices/powerSwitcherList.h"
-#include "spiConf.h"
-
 #include "bsp_q7s/gpio/gpioCallbacks.h"
 #include "bsp_q7s/core/CoreController.h"
 #include "bsp_q7s/spiCallbacks/rwSpiCallback.h"
@@ -21,6 +21,7 @@
 #include "linux/devices/SusHandler.h"
 #include "linux/csp/CspCookie.h"
 #include "linux/csp/CspComIF.h"
+#include "linux/obc/CCSDSIPCoreBridge.h"
 
 #include "mission/core/GenericFactory.h"
 #include "mission/devices/PDU1Handler.h"
@@ -44,9 +45,9 @@
 #include "mission/devices/devicedefinitions/RadSensorDefinitions.h"
 #include "mission/devices/devicedefinitions/Max31865Definitions.h"
 #include "mission/devices/devicedefinitions/RwDefinitions.h"
-#include <mission/devices/devicedefinitions/StarTrackerDefinitions.h>
+#include "mission/devices/devicedefinitions/StarTrackerDefinitions.h"
+#include "mission/devices/GPSHyperionHandler.h"
 #include "mission/utility/TmFunnel.h"
-#include "linux/obc/CCSDSIPCoreBridge.h"
 
 #include "fsfw_hal/linux/uart/UartComIF.h"
 #include "fsfw_hal/linux/uart/UartCookie.h"
@@ -75,7 +76,7 @@
 
 #include "linux/boardtest/SpiTestClass.h"
 
-#if TEST_LIBGPIOD == 1
+#if OBSW_TEST_LIBGPIOD == 1
 #include "linux/boardtest/LibgpiodTest.h"
 #endif
 
@@ -104,16 +105,18 @@ void ObjectFactory::produce(void* args){
     ObjectFactory::setStatics();
     ObjectFactory::produceGenericObjects();
     LinuxLibgpioIF* gpioComIF = nullptr;
-    createCommunicationInterfaces(&gpioComIF);
+    UartComIF* uartComIF = nullptr;
+    SpiComIF* spiComIF = nullptr;
+    createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiComIF);
     createTmpComponents();
 #if BOARD_TE0720 == 0
     new CoreController(objects::CORE_CONTROLLER);
 
     createPcduComponents();
     createRadSensorComponent(gpioComIF);
-    createSunSensorComponents(gpioComIF);
+    createSunSensorComponents(gpioComIF, spiComIF);
 #if OBSW_ADD_ACS_BOARD == 1
-    createAcsBoardComponents(gpioComIF);
+    createAcsBoardComponents(gpioComIF, uartComIF);
 #endif /* OBSW_ADD_ACS_BOARD == 1 */
     createHeaterComponents();
     createSolarArrayDeploymentComponents();
@@ -125,43 +128,38 @@ void ObjectFactory::produce(void* args){
     createRtdComponents();
 #endif /* Q7S_ADD_RTD_DEVICES == 1 */
 
-    I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE,
+    I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ,
-            std::string("/dev/i2c-0"));
+            IMTQ::MAX_REPLY_SIZE, q7s::I2C_DEFAULT_DEV);
     new IMTQHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie);
-
-#if ADD_PLOC_MPSOC == 1
-    UartCookie* mpsocUartCookie = new UartCookie(objects::RW1, std::string("/dev/ttyUL3"),
-            UartModes::NON_CANONICAL, 115200, PLOC_MPSOC::MAX_REPLY_SIZE);
-    new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocUartCookie);
-#endif /* ADD_PLOC_MPSOC */
-
     createReactionWheelComponents(gpioComIF);
 
-#if ADD_PLOC_MPSOC == 1
+#if OBSW_ADD_PLOC_MPSOC == 1
-    UartCookie* plocMpsocCookie = new UartCookie(objects::RW1, std::string("/dev/ttyUL3"),
+    UartCookie* plocMpsocCookie = new UartCookie(objects::PLOC_MPSOC_HANDLER,
-            UartModes::NON_CANONICAL, 115200, PLOC_MPSOC::MAX_REPLY_SIZE);
+            q7s::UART_PLOC_MPSOC_DEV, UartModes::NON_CANONICAL, uart::PLOC_MPSOC_BAUD,
+            PLOC_MPSOC::MAX_REPLY_SIZE);
     new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, plocMpsocCookie);
-#endif
+#endif /* OBSW_ADD_PLOC_MPSOC == 1 */
 
-#if OBSW_ADD_STAR_TRACKER == 1
+#if OBSW_ADD_PLOC_SUPERVISOR == 1
-    UartCookie* starTrackerCookie = new UartCookie(objects::START_TRACKER, std::string("/dev/ttyUL8"),
-            UartModes::NON_CANONICAL, 115200, StarTracker::MAX_FRAME_SIZE* 2 + 2);
-    starTrackerCookie->setNoFixedSizeReply();
-    new StarTrackerHandler(objects::START_TRACKER, objects::UART_COM_IF, starTrackerCookie);
-#endif
-
-#if ADD_PLOC_SUPERVISOR == 1
     UartCookie* plocSupervisorCookie = new UartCookie(objects::PLOC_SUPERVISOR_HANDLER,
-            std::string("/dev/ttyUL4"), UartModes::NON_CANONICAL, 115200,
+            q7s::UART_PLOC_SUPERVSIOR_DEV, UartModes::NON_CANONICAL, uart::PLOC_SUPERVISOR_BAUD,
             PLOC_SPV::MAX_PACKET_SIZE * 20);
     plocSupervisorCookie->setNoFixedSizeReply();
     PlocSupervisorHandler* plocSupervisor = new PlocSupervisorHandler(
             objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, plocSupervisorCookie);
     plocSupervisor->setStartUpImmediately();
-#endif
+#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
 
     new FileSystemHandler(objects::FILE_SYSTEM_HANDLER);
 
+#if OBSW_ADD_STAR_TRACKER == 1
+    UartCookie* starTrackerCookie = new UartCookie(objects::START_TRACKER,
+            q7s::UART_STAR_TRACKER_DEV, UartModes::NON_CANONICAL, uart::STAR_TRACKER_BAUD,
+            StarTracker::MAX_FRAME_SIZE* 2 + 2);
+    starTrackerCookie->setNoFixedSizeReply();
+    new StarTrackerHandler(objects::START_TRACKER, objects::UART_COM_IF, starTrackerCookie);
+#endif /* OBSW_ADD_STAR_TRACKER == 1 */
+
 #endif /* TE7020 != 0 */
 
 #if OBSW_USE_TMTC_TCP_BRIDGE == 0
@@ -174,7 +172,7 @@ void ObjectFactory::produce(void* args){
     auto tcpServer = new TcpTmTcServer(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
     sif::info << "Created TCP server for TMTC commanding with listener port " <<
             tcpServer->getTcpPort() << std::endl;
-#endif
+#endif /* OBSW_USE_TMTC_TCP_BRIDGE == 0 */
 
     /* Test Task */
 #if OBSW_ADD_TEST_CODE == 1
@@ -192,9 +190,9 @@ void ObjectFactory::createTmpComponents() {
             TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0"));
 #else
     I2cCookie* i2cCookieTmp1075tcs1 = new I2cCookie(addresses::TMP1075_TCS_1,
-            TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-1"));
+            TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV);
     I2cCookie* i2cCookieTmp1075tcs2 = new I2cCookie(addresses::TMP1075_TCS_2,
-            TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-1"));
+            TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV);
 #endif
 
     /* Temperature sensors */
@@ -208,9 +206,10 @@ void ObjectFactory::createTmpComponents() {
     (void) tmp1075Handler_2;
 }
 
-void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF **gpioComIF) {
+void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF **gpioComIF,
-    if(gpioComIF == nullptr) {
+        UartComIF** uartComIF, SpiComIF** spiComIF) {
-        sif::error << "ObjectFactory::createCommunicationInterfaces: Invalid GPIO ComIF"
+    if(gpioComIF == nullptr or uartComIF == nullptr or spiComIF == nullptr) {
+        sif::error << "ObjectFactory::createCommunicationInterfaces: Invalid passed ComIF pointer"
                 << std::endl;
     }
     *gpioComIF = new LinuxLibgpioIF(objects::GPIO_IF);
@@ -218,9 +217,9 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF **gpioComIF) {
     /* Communication interfaces */
     new CspComIF(objects::CSP_COM_IF);
     new I2cComIF(objects::I2C_COM_IF);
-    new UartComIF(objects::UART_COM_IF);
+    *uartComIF = new UartComIF(objects::UART_COM_IF);
 #if Q7S_ADD_SPI_TEST == 0
-    new SpiComIF(objects::SPI_COM_IF, *gpioComIF);
+    *spiComIF = new SpiComIF(objects::SPI_COM_IF, *gpioComIF);
 #endif /* Q7S_ADD_SPI_TEST == 0 */
 
 #if BOARD_TE0720 == 0
@@ -261,100 +260,102 @@ void ObjectFactory::createPcduComponents() {
 
 void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
     GpioCookie* gpioCookieRadSensor = new GpioCookie;
-    GpiodRegular* chipSelectRadSensor = new GpiodRegular(std::string("gpiochip5"), 19,
+    GpiodRegular* chipSelectRadSensor = new GpiodRegular(q7s::GPIO_RAD_SENSOR_CHIP,
-            std::string("Chip Select Radiation Sensor"), gpio::OUT, 1);
+            q7s::GPIO_RAD_SENSOR_CS, "Chip Select Radiation Sensor", gpio::OUT, 1);
     gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, chipSelectRadSensor);
     gpioComIF->addGpios(gpioCookieRadSensor);
 
     SpiCookie* spiCookieRadSensor = new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR,
-            std::string("/dev/spidev2.0"), RAD_SENSOR::READ_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), RAD_SENSOR::READ_SIZE, spi::DEFAULT_MAX_1227_MODE,
             spi::DEFAULT_MAX_1227_SPEED);
     new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF, spiCookieRadSensor);
 }
 
-void ObjectFactory::createSunSensorComponents(LinuxLibgpioIF *gpioComIF) {
+void ObjectFactory::createSunSensorComponents(LinuxLibgpioIF *gpioComIF,
+        SpiComIF* spiComIF) {
     GpioCookie* gpioCookieSus = new GpioCookie();
+    GpioCallback* susgpio = nullptr;
 
-    GpioCallback* susgpio = new GpioCallback(std::string("Chip select SUS 1"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 1", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_1, susgpio);
-    susgpio = new GpioCallback(std::string("Chip select SUS 2"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 2", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_2, susgpio);
-    susgpio = new GpioCallback(std::string("Chip select SUS 3"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 3", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_3, susgpio);
-    susgpio = new GpioCallback(std::string("Chip select SUS 4"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 4", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_4, susgpio);
-    susgpio = new GpioCallback(std::string("Chip select SUS 5"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 5", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_5, susgpio);
-    susgpio = new GpioCallback(std::string("Chip select SUS 6"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 6", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_6, susgpio);
-    susgpio = new GpioCallback(std::string("Chip select SUS 7"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 7", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_7, susgpio);
-    susgpio = new GpioCallback(std::string("Chip select SUS 8"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 8", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_8, susgpio);
-    susgpio = new GpioCallback(std::string("Chip select SUS 9"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 9", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_9, susgpio);
-    susgpio = new GpioCallback(std::string("Chip select SUS 10"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 10", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_10, susgpio);
-    susgpio = new GpioCallback(std::string("Chip select SUS 11"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 11", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_11, susgpio);
-    susgpio = new GpioCallback(std::string("Chip select SUS 12"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 12", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_12, susgpio);
-    susgpio = new GpioCallback(std::string("Chip select SUS 13"), gpio::OUT, 1,
+    susgpio = new GpioCallback("Chip select SUS 13", gpio::OUT, 1,
            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieSus->addGpio(gpioIds::CS_SUS_13, susgpio);
 
     gpioComIF->addGpios(gpioCookieSus);
 
     SpiCookie* spiCookieSus1 = new SpiCookie(addresses::SUS_1, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
     SpiCookie* spiCookieSus2 = new SpiCookie(addresses::SUS_2, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
     SpiCookie* spiCookieSus3 = new SpiCookie(addresses::SUS_3, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
     SpiCookie* spiCookieSus4 = new SpiCookie(addresses::SUS_4, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
     SpiCookie* spiCookieSus5 = new SpiCookie(addresses::SUS_5, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
     SpiCookie* spiCookieSus6 = new SpiCookie(addresses::SUS_6, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
     SpiCookie* spiCookieSus7 = new SpiCookie(addresses::SUS_7, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
     SpiCookie* spiCookieSus8 = new SpiCookie(addresses::SUS_8, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
     SpiCookie* spiCookieSus9 = new SpiCookie(addresses::SUS_9, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
     SpiCookie* spiCookieSus10 = new SpiCookie(addresses::SUS_10, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
     SpiCookie* spiCookieSus11 = new SpiCookie(addresses::SUS_11, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
     SpiCookie* spiCookieSus12 = new SpiCookie(addresses::SUS_12, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
     SpiCookie* spiCookieSus13 = new SpiCookie(addresses::SUS_13, gpio::NO_GPIO,
-            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            std::string(q7s::SPI_DEFAULT_DEV), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
             SUS::MAX1227_SPI_FREQ);
 
     new SusHandler(objects::SUS_1, objects::SPI_COM_IF, spiCookieSus1, gpioComIF,
@@ -385,38 +386,39 @@ void ObjectFactory::createSunSensorComponents(LinuxLibgpioIF *gpioComIF) {
             gpioIds::CS_SUS_13);
 }
 
-void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF *gpioComIF) {
+void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF *gpioComIF, UartComIF* uartComIF) {
     GpioCookie* gpioCookieAcsBoard = new GpioCookie();
     GpiodRegular* gpio = nullptr;
-    gpio = new GpiodRegular(std::string("gpiochip5"), 1, std::string("CS_GYRO_0_ADIS"),
+    // TODO: Determine new Gyro GPIO pins
-            gpio::OUT, gpio::HIGH);
+    gpio = new GpiodRegular(q7s::GPIO_ACS_BOARD_DEFAULT_CHIP, q7s::GPIO_GYRO_0_ADIS_CS,
+            "CS_GYRO_0_ADIS", gpio::OUT, gpio::HIGH);
     gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio);
-    gpio = new GpiodRegular(std::string("gpiochip5"), 7, std::string("CS_GYRO_1_L3G"),
+    gpio = new GpiodRegular(q7s::GPIO_ACS_BOARD_DEFAULT_CHIP, q7s::GPIO_GYRO_1_L3G_CS,
-            gpio::OUT, gpio::HIGH);
+            "CS_GYRO_1_L3G", gpio::OUT, gpio::HIGH);
     gpioCookieAcsBoard->addGpio(gpioIds::GYRO_1_L3G_CS, gpio);
-    gpio = new GpiodRegular(std::string("gpiochip5"), 3, std::string("CS_GYRO_2_L3G"),
+    gpio = new GpiodRegular(q7s::GPIO_ACS_BOARD_DEFAULT_CHIP, q7s::GPIO_GYRO_2_ADIS_CS,
-            gpio::OUT, gpio::HIGH);
+            "CS_GYRO_2_ADIS", gpio::OUT, gpio::HIGH);
-    gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_L3G_CS, gpio);
+    gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ADIS_CS, gpio);
+    gpio = new GpiodRegular(q7s::GPIO_ACS_BOARD_DEFAULT_CHIP, q7s::GPIO_GYRO_3_L3G_CS,
+            "CS_GYRO_3_L3G", gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::GYRO_3_L3G_CS, gpio);
 
-    gpio = new GpiodRegular(std::string("gpiochip5"), 5, std::string("CS_MGM_0_LIS3_A"),
+    gpio = new GpiodRegular(q7s::GPIO_ACS_BOARD_DEFAULT_CHIP, q7s::GPIO_MGM_0_LIS3_CS,
-            gpio::OUT, gpio::HIGH);
+            "CS_MGM_0_LIS3_A", gpio::OUT, gpio::HIGH);
     gpioCookieAcsBoard->addGpio(gpioIds::MGM_0_LIS3_CS, gpio);
-
+    gpio = new GpiodRegular(q7s::GPIO_ACS_BOARD_DEFAULT_CHIP, q7s::GPIO_MGM_1_RM3100_CS,
-    gpio = new GpiodRegular(std::string("gpiochip5"), 16, std::string("CS_MGM_1_RM3100_A"),
+            "CS_MGM_1_RM3100_A", gpio::OUT, gpio::HIGH);
-            gpio::OUT, gpio::HIGH);
     gpioCookieAcsBoard->addGpio(gpioIds::MGM_1_RM3100_CS, gpio);
-
+    gpio = new GpiodRegular(q7s::GPIO_MGM2_LIS3_CHIP, q7s::GPIO_MGM_2_LIS3_CS,
-    gpio = new GpiodRegular(std::string("gpiochip6"), 0, std::string("CS_MGM_2_LIS3_B"),
+            "CS_MGM_2_LIS3_B", gpio::OUT, gpio::HIGH);
-            gpio::OUT, gpio::HIGH);
     gpioCookieAcsBoard->addGpio(gpioIds::MGM_2_LIS3_CS, gpio);
-
+    gpio = new GpiodRegular(q7s::GPIO_ACS_BOARD_DEFAULT_CHIP, q7s::GPIO_MGM_3_RM3100_CS,
-    gpio = new GpiodRegular(std::string("gpiochip5"), 10, std::string("CS_MGM_3_RM3100_B"),
+            "CS_MGM_3_RM3100_B", gpio::OUT, gpio::HIGH);
-            gpio::OUT, gpio::HIGH);
     gpioCookieAcsBoard->addGpio(gpioIds::MGM_3_RM3100_CS, gpio);
 
     gpioComIF->addGpios(gpioCookieAcsBoard);
 
-    std::string spiDev = "/dev/spidev2.0";
+    std::string spiDev = q7s::SPI_DEFAULT_DEV;
     SpiCookie* spiCookie = new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, spiDev,
             MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
     auto mgmLis3Handler = new MGMHandlerLIS3MDL(objects::MGM_0_LIS3_HANDLER,
@@ -457,6 +459,14 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF *gpioComIF) {
 //    gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_2_L3G_HANDLER, objects::SPI_COM_IF,
 //            spiCookie);
 //    gyroL3gHandler->setStartUpImmediately();
+
+    // TODO: Add GPS device handlers
+//    auto uartCookieGps0 = new UartCookie(objects::GPS0_HANDLER, deviceFile, uartMode, baudrate,
+//            maxReplyLen);
+//    auto uartCookieGps1 = new UartCookie(objects::GPS0_HANDLER, deviceFile, uartMode, baudrate,
+//            maxReplyLen);
+//    new GPSHyperionHandler(objects::GPS0_HANDLER, uartComIF);
+//    new GPSHyperionHandler(objects::GPS1_HANDLER, uartComIF);
 }
 
 void ObjectFactory::createHeaterComponents() {
@@ -464,38 +474,38 @@ void ObjectFactory::createHeaterComponents() {
     GpioCookie* heaterGpiosCookie = new GpioCookie;
 
     /* Pin H2-11 on stack connector */
-    GpiodRegular* gpioConfigHeater0 = new GpiodRegular(std::string("gpiochip7"), 6,
+    GpiodRegular* gpioConfigHeater0 = new GpiodRegular(q7s::GPIO_HEATER_CHIP,
-            std::string("Heater0"), gpio::OUT, 0);
+            q7s::GPIO_HEATER_0_PIN, "Heater0", gpio::OUT, 0);
     heaterGpiosCookie->addGpio(gpioIds::HEATER_0, gpioConfigHeater0);
 
     /* Pin H2-12 on stack connector */
-    GpiodRegular* gpioConfigHeater1 = new GpiodRegular(std::string("gpiochip7"), 12,
+    GpiodRegular* gpioConfigHeater1 = new GpiodRegular(q7s::GPIO_HEATER_CHIP,
-            std::string("Heater1"), gpio::OUT, 0);
+            q7s::GPIO_HEATER_1_PIN, "Heater1", gpio::OUT, 0);
     heaterGpiosCookie->addGpio(gpioIds::HEATER_1, gpioConfigHeater1);
 
     /* Pin H2-13 on stack connector */
-    GpiodRegular* gpioConfigHeater2 = new GpiodRegular(std::string("gpiochip7"), 7,
+    GpiodRegular* gpioConfigHeater2 = new GpiodRegular(q7s::GPIO_HEATER_CHIP,
-            std::string("Heater2"), gpio::OUT, 0);
+            q7s::GPIO_HEATER_2_PIN, "Heater2", gpio::OUT, 0);
     heaterGpiosCookie->addGpio(gpioIds::HEATER_2, gpioConfigHeater2);
 
-    GpiodRegular* gpioConfigHeater3 = new GpiodRegular(std::string("gpiochip7"), 5,
+    GpiodRegular* gpioConfigHeater3 = new GpiodRegular(q7s::GPIO_HEATER_CHIP,
-            std::string("Heater3"), gpio::OUT, 0);
+            q7s::GPIO_HEATER_3_PIN, "Heater3", gpio::OUT, 0);
     heaterGpiosCookie->addGpio(gpioIds::HEATER_3, gpioConfigHeater3);
 
-    GpiodRegular* gpioConfigHeater4 = new GpiodRegular(std::string("gpiochip7"), 3,
+    GpiodRegular* gpioConfigHeater4 = new GpiodRegular(q7s::GPIO_HEATER_CHIP,
-            std::string("Heater4"), gpio::OUT, 0);
+            q7s::GPIO_HEATER_4_PIN, "Heater4", gpio::OUT, 0);
     heaterGpiosCookie->addGpio(gpioIds::HEATER_4, gpioConfigHeater4);
 
-    GpiodRegular* gpioConfigHeater5 = new GpiodRegular(std::string("gpiochip7"), 0,
+    GpiodRegular* gpioConfigHeater5 = new GpiodRegular(q7s::GPIO_HEATER_CHIP,
-            std::string("Heater5"), gpio::OUT, 0);
+            q7s::GPIO_HEATER_5_PIN, "Heater5", gpio::OUT, 0);
     heaterGpiosCookie->addGpio(gpioIds::HEATER_5, gpioConfigHeater5);
 
-    GpiodRegular* gpioConfigHeater6 = new GpiodRegular(std::string("gpiochip7"), 1,
+    GpiodRegular* gpioConfigHeater6 = new GpiodRegular(q7s::GPIO_HEATER_CHIP,
-            std::string("Heater6"), gpio::OUT, 0);
+            q7s::GPIO_HEATER_6_PIN, "Heater6", gpio::OUT, 0);
     heaterGpiosCookie->addGpio(gpioIds::HEATER_6, gpioConfigHeater6);
 
-    GpiodRegular* gpioConfigHeater7 = new GpiodRegular(std::string("gpiochip7"), 11,
+    GpiodRegular* gpioConfigHeater7 = new GpiodRegular(q7s::GPIO_HEATER_CHIP,
-            std::string("Heater7"), gpio::OUT, 0);
+            q7s::GPIO_HEATER_7_PIN, "Heater7", gpio::OUT, 0);
     heaterGpiosCookie->addGpio(gpioIds::HEATER_7, gpioConfigHeater7);
 
     new HeaterHandler(objects::HEATER_HANDLER, objects::GPIO_IF, heaterGpiosCookie,
@@ -505,11 +515,11 @@ void ObjectFactory::createHeaterComponents() {
 void ObjectFactory::createSolarArrayDeploymentComponents() {
     GpioCookie* solarArrayDeplCookie = new GpioCookie;
 
-    GpiodRegular* gpioConfigDeplSA0 = new GpiodRegular(std::string("gpiochip7"), 4,
+    GpiodRegular* gpioConfigDeplSA0 = new GpiodRegular(q7s::GPIO_SOLAR_ARR_DEPL_CHIP,
-                std::string("DeplSA1"), gpio::OUT, 0);
+            q7s::GPIO_SOL_DEPL_SA_0_PIN, "DeplSA0", gpio::OUT, 0);
     solarArrayDeplCookie->addGpio(gpioIds::DEPLSA1, gpioConfigDeplSA0);
-    GpiodRegular* gpioConfigDeplSA1 = new GpiodRegular(std::string("gpiochip7"), 2,
+    GpiodRegular* gpioConfigDeplSA1 = new GpiodRegular(q7s::GPIO_SOLAR_ARR_DEPL_CHIP,
-                std::string("DeplSA2"), gpio::OUT, 0);
+            q7s::GPIO_SOL_DEPL_SA_1_PIN, "DeplSA1", gpio::OUT, 0);
     solarArrayDeplCookie->addGpio(gpioIds::DEPLSA2, gpioConfigDeplSA1);
 
     //TODO: Find out burn time. For now set to 1000 ms.
@@ -529,105 +539,105 @@ void ObjectFactory::createSyrlinksComponents() {
 void ObjectFactory::createRtdComponents(LinuxLibgpioIF *gpioComIF) {
     GpioCookie* rtdGpioCookie = new GpioCookie;
 
-    GpioCallback* gpioRtdIc3 = new GpioCallback(std::string("Chip select RTD IC3"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc3 = new GpioCallback("Chip select RTD IC3", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC3, gpioRtdIc3);
-    GpioCallback* gpioRtdIc4 = new GpioCallback(std::string("Chip select RTD IC4"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc4 = new GpioCallback("Chip select RTD IC4", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC4, gpioRtdIc4);
-    GpioCallback* gpioRtdIc5 = new GpioCallback(std::string("Chip select RTD IC5"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc5 = new GpioCallback("Chip select RTD IC5", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC5, gpioRtdIc5);
-    GpioCallback* gpioRtdIc6 = new GpioCallback(std::string("Chip select RTD IC6"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc6 = new GpioCallback("Chip select RTD IC6", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC6, gpioRtdIc6);
-    GpioCallback* gpioRtdIc7 = new GpioCallback(std::string("Chip select RTD IC7"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc7 = new GpioCallback("Chip select RTD IC7", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC7, gpioRtdIc7);
-    GpioCallback* gpioRtdIc8 = new GpioCallback(std::string("Chip select RTD IC8"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc8 = new GpioCallback("Chip select RTD IC8", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC8, gpioRtdIc8);
-    GpioCallback* gpioRtdIc9 = new GpioCallback(std::string("Chip select RTD IC9"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc9 = new GpioCallback("Chip select RTD IC9", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC9, gpioRtdIc9);
-    GpioCallback* gpioRtdIc10 = new GpioCallback(std::string("Chip select RTD IC10"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc10 = new GpioCallback("Chip select RTD IC10", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC10, gpioRtdIc10);
-    GpioCallback* gpioRtdIc11 = new GpioCallback(std::string("Chip select RTD IC11"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc11 = new GpioCallback("Chip select RTD IC11", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC11, gpioRtdIc11);
-    GpioCallback* gpioRtdIc12 = new GpioCallback(std::string("Chip select RTD IC12"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc12 = new GpioCallback("Chip select RTD IC12", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC12, gpioRtdIc12);
-    GpioCallback* gpioRtdIc13 = new GpioCallback(std::string("Chip select RTD IC13"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc13 = new GpioCallback("Chip select RTD IC13", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC13, gpioRtdIc13);
-    GpioCallback* gpioRtdIc14 = new GpioCallback(std::string("Chip select RTD IC14"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc14 = new GpioCallback("Chip select RTD IC14", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC14, gpioRtdIc14);
-    GpioCallback* gpioRtdIc15 = new GpioCallback(std::string("Chip select RTD IC15"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc15 = new GpioCallback("Chip select RTD IC15", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC15, gpioRtdIc15);
-    GpioCallback* gpioRtdIc16 = new GpioCallback(std::string("Chip select RTD IC16"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc16 = new GpioCallback("Chip select RTD IC16", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC16, gpioRtdIc16);
-    GpioCallback* gpioRtdIc17 = new GpioCallback(std::string("Chip select RTD IC17"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc17 = new GpioCallback("Chip select RTD IC17", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC17, gpioRtdIc17);
-    GpioCallback* gpioRtdIc18 = new GpioCallback(std::string("Chip select RTD IC18"), gpio::OUT, 1,
+    GpioCallback* gpioRtdIc18 = new GpioCallback("Chip select RTD IC18", gpio::OUT, gpio::HIGH,
             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     rtdGpioCookie->addGpio(gpioIds::RTD_IC18, gpioRtdIc18);
 
     gpioComIF->addGpios(rtdGpioCookie);
 
     SpiCookie* spiRtdIc3 = new SpiCookie(addresses::RTD_IC3, gpioIds::RTD_IC3,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_3, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc4 = new SpiCookie(addresses::RTD_IC4, gpioIds::RTD_IC4,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc5 = new SpiCookie(addresses::RTD_IC5, gpioIds::RTD_IC5,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc6 = new SpiCookie(addresses::RTD_IC6, gpioIds::RTD_IC6,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc7 = new SpiCookie(addresses::RTD_IC7, gpioIds::RTD_IC7,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc8 = new SpiCookie(addresses::RTD_IC8, gpioIds::RTD_IC8,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc9 = new SpiCookie(addresses::RTD_IC9, gpioIds::RTD_IC9,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc10 = new SpiCookie(addresses::RTD_IC10, gpioIds::RTD_IC10,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc11 = new SpiCookie(addresses::RTD_IC11, gpioIds::RTD_IC11,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc12 = new SpiCookie(addresses::RTD_IC12, gpioIds::RTD_IC12,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc13 = new SpiCookie(addresses::RTD_IC13, gpioIds::RTD_IC13,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc14 = new SpiCookie(addresses::RTD_IC14, gpioIds::RTD_IC14,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc15 = new SpiCookie(addresses::RTD_IC15, gpioIds::RTD_IC15,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 3900000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc16 = new SpiCookie(addresses::RTD_IC16, gpioIds::RTD_IC16,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            std::string(q7s::SPI_DEFAULT_DEV), Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc17 = new SpiCookie(addresses::RTD_IC17, gpioIds::RTD_IC17,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
     SpiCookie* spiRtdIc18 = new SpiCookie(addresses::RTD_IC18, gpioIds::RTD_IC18,
-            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE,
-            spi::SpiModes::MODE_1, 2000000);
+            spi::SpiModes::MODE_1, spi::RTD_SPEED);
 
     Max31865PT1000Handler* rtdIc3 = new Max31865PT1000Handler(objects::RTD_IC3,
             objects::SPI_COM_IF, spiRtdIc3, 0); // 0 is switchId
@@ -682,30 +692,30 @@ void ObjectFactory::createRtdComponents(LinuxLibgpioIF *gpioComIF) {
 
 void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
     GpioCookie* gpioCookieRw = new GpioCookie;
-    GpioCallback* csRw1 = new GpioCallback(std::string("Chip select reaction wheel 1"), gpio::OUT,
+    GpioCallback* csRw1 = new GpioCallback("Chip select reaction wheel 1", gpio::OUT,
-            1, &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+            gpio::HIGH, &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieRw->addGpio(gpioIds::CS_RW1, csRw1);
-    GpioCallback* csRw2 = new GpioCallback(std::string("Chip select reaction wheel 2"), gpio::OUT,
+    GpioCallback* csRw2 = new GpioCallback("Chip select reaction wheel 2", gpio::OUT,
-            1, &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+            gpio::HIGH, &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieRw->addGpio(gpioIds::CS_RW2, csRw2);
-    GpioCallback* csRw3 = new GpioCallback(std::string("Chip select reaction wheel 3"), gpio::OUT,
+    GpioCallback* csRw3 = new GpioCallback("Chip select reaction wheel 3", gpio::OUT,
-            1, &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+            gpio::HIGH, &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieRw->addGpio(gpioIds::CS_RW3, csRw3);
-    GpioCallback* csRw4 = new GpioCallback(std::string("Chip select reaction wheel 4"), gpio::OUT,
+    GpioCallback* csRw4 = new GpioCallback("Chip select reaction wheel 4", gpio::OUT,
-            1, &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+            gpio::HIGH, &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
     gpioCookieRw->addGpio(gpioIds::CS_RW4, csRw4);
 
-    GpiodRegular* enRw1 = new GpiodRegular(std::string("gpiochip5"), 7,
+    GpiodRegular* enRw1 = new GpiodRegular(q7s::GPIO_RW_DEFAULT_CHIP, q7s::GPIO_RW_0_CS,
-                std::string("Enable reaction wheel 1"), gpio::OUT, 0);
+            "Enable reaction wheel 1", gpio::OUT, 0);
     gpioCookieRw->addGpio(gpioIds::EN_RW1, enRw1);
-    GpiodRegular* enRw2 = new GpiodRegular(std::string("gpiochip5"), 3,
+    GpiodRegular* enRw2 = new GpiodRegular(q7s::GPIO_RW_DEFAULT_CHIP, q7s::GPIO_RW_1_CS,
-                std::string("Enable reaction wheel 2"), gpio::OUT, 0);
+            "Enable reaction wheel 2", gpio::OUT, 0);
     gpioCookieRw->addGpio(gpioIds::EN_RW2, enRw2);
-    GpiodRegular* enRw3 = new GpiodRegular(std::string("gpiochip5"), 11,
+    GpiodRegular* enRw3 = new GpiodRegular(q7s::GPIO_RW_DEFAULT_CHIP, q7s::GPIO_RW_2_CS,
-                std::string("Enable reaction wheel 3"), gpio::OUT, 0);
+            "Enable reaction wheel 3", gpio::OUT, 0);
     gpioCookieRw->addGpio(gpioIds::EN_RW3, enRw3);
-    GpiodRegular* enRw4 = new GpiodRegular(std::string("gpiochip5"), 6,
+    GpiodRegular* enRw4 = new GpiodRegular(q7s::GPIO_RW_DEFAULT_CHIP, q7s::GPIO_RW_3_CS,
-                std::string("Enable reaction wheel 4"), gpio::OUT, 0);
+            "Enable reaction wheel 4", gpio::OUT, 0);
     gpioCookieRw->addGpio(gpioIds::EN_RW4, enRw4);
 
     /**
@@ -713,22 +723,22 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
      * the PS SPI peripheral from the SPI interface and route out the SPI lines of the AXI SPI core.
      * Per default the PS SPI is selected (EMIO = 0).
      */
-    GpiodRegular* spiMux = new GpiodRegular(std::string("gpiochip11"), 54,
+    GpiodRegular* spiMux = new GpiodRegular(q7s::GPIO_RW_SPI_MUX_CHIP, q7s::GPIO_RW_SPI_MUX_CS,
-                std::string("EMIO 0 SPI Mux"), gpio::OUT, 0);
+            "EMIO 0 SPI Mux", gpio::OUT, 0);
     gpioCookieRw->addGpio(gpioIds::SPI_MUX, spiMux);
 
     gpioComIF->addGpios(gpioCookieRw);
 
-    auto rw1SpiCookie = new SpiCookie(addresses::RW1, gpioIds::CS_RW1, "/dev/spidev3.0",
+    auto rw1SpiCookie = new SpiCookie(addresses::RW1, gpioIds::CS_RW1, q7s::SPI_RW_DEV,
             RwDefinitions::MAX_REPLY_SIZE, spi::RW_MODE, spi::RW_SPEED, &rwSpiCallback::spiCallback,
             nullptr);
-    auto rw2SpiCookie = new SpiCookie(addresses::RW2, gpioIds::CS_RW2, "/dev/spidev3.0",
+    auto rw2SpiCookie = new SpiCookie(addresses::RW2, gpioIds::CS_RW2, q7s::SPI_RW_DEV,
             RwDefinitions::MAX_REPLY_SIZE, spi::RW_MODE, spi::RW_SPEED, &rwSpiCallback::spiCallback,
             nullptr);
-    auto rw3SpiCookie = new SpiCookie(addresses::RW3, gpioIds::CS_RW3, "/dev/spidev3.0",
+    auto rw3SpiCookie = new SpiCookie(addresses::RW3, gpioIds::CS_RW3, q7s::SPI_RW_DEV,
             RwDefinitions::MAX_REPLY_SIZE, spi::RW_MODE, spi::RW_SPEED, &rwSpiCallback::spiCallback,
             nullptr);
-    auto rw4SpiCookie = new SpiCookie(addresses::RW4, gpioIds::CS_RW4, "/dev/spidev3.0",
+    auto rw4SpiCookie = new SpiCookie(addresses::RW4, gpioIds::CS_RW4, q7s::SPI_RW_DEV,
             RwDefinitions::MAX_REPLY_SIZE, spi::RW_MODE, spi::RW_SPEED, &rwSpiCallback::spiCallback,
             nullptr);
 
@@ -750,9 +760,12 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
 }
 
 void ObjectFactory::createTestComponents() {
-    new Q7STestTask(objects::TEST_TASK);
 
-#if BOARD_TE0720 == 1 && TEST_LIBGPIOD == 1
+#if BOARD_TE0720 == 0
+    new Q7STestTask(objects::TEST_TASK);
+#endif
+
+#if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1
     /* Configure MIO0 as input */
     GpiodRegular gpioConfigMio0(std::string("gpiochip0"), 0,
             std::string("MIO0"), gpio::IN, 0);
@@ -761,7 +774,7 @@ void ObjectFactory::createTestComponents() {
     new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookie);
 #endif
 
-#if BOARD_TE0720 == 1 && TEST_SUS_HANDLER == 1
+#if BOARD_TE0720 == 1 && OBSW_TEST_SUS_HANDLER == 1
     GpioCookie* gpioCookieSus = new GpioCookie;
     GpiodRegular* chipSelectSus = new GpiodRegular(std::string("gpiochip1"), 9,
             std::string("Chip Select Sus Sensor"), gpio::OUT, 1);
@@ -775,7 +788,7 @@ void ObjectFactory::createTestComponents() {
             gpioIds::CS_SUS_1);
 #endif
 
-#if BOARD_TE0720 == 1 && TEST_CCSDS_BRIDGE == 1
+#if BOARD_TE0720 == 1 && OBSW_TEST_CCSDS_BRIDGE == 1
     GpioCookie* gpioCookieCcsdsIp = new GpioCookie;
     GpiodRegular* papbBusyN = new GpiodRegular(std::string("gpiochip0"), 0, std::string("PAPBBusy_N"));
     gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_BUSY_N, papbBusyN);
@@ -789,7 +802,7 @@ void ObjectFactory::createTestComponents() {
             gpioIds::PAPB_BUSY_N, gpioIds::PAPB_EMPTY);
 #endif
 
-#if BOARD_TE0720 == 1 && TEST_RADIATION_SENSOR_HANDLER == 1
+#if BOARD_TE0720 == 1 && OBSW_TEST_RADIATION_SENSOR_HANDLER == 1
     GpioCookie* gpioCookieRadSensor = new GpioCookie;
     GpiodRegular* chipSelectRadSensor = new GpiodRegular(std::string("gpiochip1"), 0,
             std::string("Chip select radiation sensor"), gpio::OUT, 1);
@@ -805,7 +818,7 @@ void ObjectFactory::createTestComponents() {
     radSensor->setStartUpImmediately();
 #endif
 
-#if BOARD_TE0720 == 1 && ADD_PLOC_MPSOC == 1
+#if BOARD_TE0720 == 1 && OBSW_ADD_PLOC_MPSOC == 1
     UartCookie* plocUartCookie = new UartCookie(std::string("/dev/ttyPS1"), 115200,
             PLOC_MPSOC::MAX_REPLY_SIZE);
     /* Testing PlocMPSoCHandler on TE0720-03-1CFA */
@@ -814,7 +827,7 @@ void ObjectFactory::createTestComponents() {
     mpsocPlocHandler->setStartUpImmediately();
 #endif
 
-#if BOARD_TE0720 == 1 && TE0720_HEATER_TEST == 1
+#if BOARD_TE0720 == 1 && OBSW_TEST_TE7020_HEATER == 1
     /* Configuration for MIO0 on TE0720-03-1CFA */
     GpiodRegular* heaterGpio = new GpiodRegular(std::string("gpiochip0"), 0, std::string("MIO0"), gpio::IN, 0);
     GpioCookie* gpioCookie = new GpioCookie;
@@ -823,7 +836,7 @@ void ObjectFactory::createTestComponents() {
             pcduSwitches::TCS_BOARD_8V_HEATER_IN);
 #endif
 
-#if BOARD_TE0720 == 1 && ADD_PLOC_SUPERVISOR == 1
+#if BOARD_TE0720 == 1 && OBSW_ADD_PLOC_SUPERVISOR == 1
     /* Configuration for MIO0 on TE0720-03-1CFA */
     UartCookie* plocSupervisorCookie = new UartCookie(objects::PLOC_SUPERVISOR_HANDLER,
             std::string("/dev/ttyPS1"), UartModes::NON_CANONICAL, 115200,
@@ -832,7 +845,6 @@ void ObjectFactory::createTestComponents() {
     PlocSupervisorHandler* plocSupervisor = new PlocSupervisorHandler(
             objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, plocSupervisorCookie);
     plocSupervisor->setStartUpImmediately();
-
 #endif
 
 #if Q7S_ADD_SPI_TEST == 1

bsp_q7s/core/ObjectFactory.h

@@ -2,18 +2,21 @@
 #define BSP_Q7S_OBJECTFACTORY_H_
 
 class LinuxLibgpioIF;
+class UartComIF;
+class SpiComIF;
 
 namespace ObjectFactory {
 
 void setStatics();
 void produce(void* args);
 
-void createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF);
+void createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, UartComIF** uartComIF,
+        SpiComIF** spiComIF);
 void createTmpComponents();
 void createPcduComponents();
 void createRadSensorComponent(LinuxLibgpioIF* gpioComIF);
-void createSunSensorComponents(LinuxLibgpioIF* gpioComIF);
+void createSunSensorComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF);
-void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF);
+void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF);
 void createHeaterComponents();
 void createSolarArrayDeploymentComponents();
 void createSyrlinksComponents();

bsp_q7s/devices/PlocSupervisorHandler.cpp

@@ -740,7 +740,7 @@ ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
 
     nextReplyId = PLOC_SPV::EXE_REPORT;
 
-#if OBSW_VERBOSE_LEVEL >= 1 && PLOC_SUPERVISOR_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
     sif::info << "PlocSupervisorHandler::handleHkReport: temp_ps: " << hkset.tempPs << std::endl;
     sif::info << "PlocSupervisorHandler::handleHkReport: temp_pl: " << hkset.tempPl << std::endl;
     sif::info << "PlocSupervisorHandler::handleHkReport: temp_sup: " << hkset.tempSup << std::endl;
@@ -797,7 +797,7 @@ ReturnValue_t PlocSupervisorHandler::handleBootStatusReport(const uint8_t* data)
 
     nextReplyId = PLOC_SPV::EXE_REPORT;
 
-#if OBSW_VERBOSE_LEVEL >= 1 && PLOC_SUPERVISOR_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
     sif::info << "PlocSupervisorHandler::handleBootStatusReport: Boot signal: "
             << static_cast<unsigned int>(bootStatusReport.bootSignal.value) << std::endl;
     sif::info << "PlocSupervisorHandler::handleBootStatusReport: Reset counter: "
@@ -875,7 +875,7 @@ ReturnValue_t PlocSupervisorHandler::handleLatchupStatusReport(const uint8_t* da
 
     nextReplyId = PLOC_SPV::EXE_REPORT;
 
-#if OBSW_VERBOSE_LEVEL >= 1 && PLOC_SUPERVISOR_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
     sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: Latchup ID: "
             << static_cast<unsigned int>(latchupStatusReport.id.value) << std::endl;
     sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: CNT0: "

bsp_q7s/spiCallbacks/rwSpiCallback.cpp

@@ -24,7 +24,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
 
     int fileDescriptor = 0;
     std::string device = cookie->getSpiDevice();
-    UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "rwSpiCallback::spiCallback: ");
+    UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "rwSpiCallback::spiCallback");
     if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
         sif::error << "rwSpiCallback::spiCallback: Failed to open device file" << std::endl;
         return SpiComIF::OPENING_FILE_FAILED;

common/config/commonObjects.h

@@ -75,10 +75,10 @@ enum commonObjects: uint32_t {
     GPS0_HANDLER = 0x44130045,
     GPS1_HANDLER = 0x44130146,
 
-    RW1 = 0x44120001,
+    RW1 = 0x44120047,
-    RW2 = 0x44120002,
+    RW2 = 0x44120148,
-    RW3 = 0x44120003,
+    RW3 = 0x44120249,
-    RW4 = 0x44120004,
+    RW4 = 0x44120350,
 
     START_TRACKER = 0x44130001,
 

common/config/devConf.h

@@ -1,5 +1,5 @@
-#ifndef COMMON_CONFIG_SPICONF_H_
+#ifndef COMMON_CONFIG_DEVCONF_H_
-#define COMMON_CONFIG_SPICONF_H_
+#define COMMON_CONFIG_DEVCONF_H_
 
 #include <cstdint>
 #include <fsfw_hal/linux/spi/spiDefinitions.h>
@@ -29,6 +29,16 @@ static constexpr spi::SpiModes DEFAULT_ADIS16507_MODE = spi::SpiModes::MODE_3;
 static constexpr uint32_t RW_SPEED = 300000;
 static constexpr spi::SpiModes RW_MODE = spi::SpiModes::MODE_0;
 
+static constexpr uint32_t RTD_SPEED = 2000000;
+
 }
 
-#endif /* COMMON_CONFIG_SPICONF_H_ */
+namespace uart {
+
+static constexpr uint32_t PLOC_MPSOC_BAUD = 115200;
+static constexpr uint32_t PLOC_SUPERVISOR_BAUD = 115200;
+static constexpr uint32_t STAR_TRACKER_BAUD = 115200;
+
+}
+
+#endif /* COMMON_CONFIG_DEVCONF_H_ */

fsfw

@@ -1 +1 @@
-Subproject commit 1ac372cb89fabc868aa9cc6ef024f822c744eaed
+Subproject commit 882da68a2f0c1301d433d517c449c9c31f3cb35e

linux/boardtest/SpiTestClass.cpp

@@ -85,7 +85,7 @@ void SpiTestClass::performRm3100Test(uint8_t mgmId) {
 
 
     UnixFileGuard fileHelper(deviceName, &fileDescriptor, O_RDWR,
-            "SpiComIF::initializeInterface: ");
+            "SpiComIF::initializeInterface");
     if(fileHelper.getOpenResult()) {
         sif::error << "SpiTestClass::performRm3100Test: File descriptor could not be opened!"
                 << std::endl;
@@ -184,7 +184,7 @@ void SpiTestClass::performLis3MdlTest(uint8_t lis3Id) {
     int fileDescriptor = 0;
 
     UnixFileGuard fileHelper(deviceName, &fileDescriptor, O_RDWR,
-            "SpiComIF::initializeInterface: ");
+            "SpiComIF::initializeInterface");
     if(fileHelper.getOpenResult()) {
         sif::error << "SpiTestClass::performLis3Mdl3100Test: File descriptor could not be opened!"
                 << std::endl;
@@ -223,7 +223,7 @@ void SpiTestClass::performL3gTest(uint8_t l3gId) {
         currentGpioId = gpioIds::GYRO_1_L3G_CS;
     }
     else {
-        currentGpioId = gpioIds::GYRO_2_L3G_CS;
+        currentGpioId = gpioIds::GYRO_3_L3G_CS;
     }
     uint32_t spiSpeed = 3'900'000;
     spi::SpiModes spiMode = spi::SpiModes::MODE_3;
@@ -235,7 +235,7 @@ void SpiTestClass::performL3gTest(uint8_t l3gId) {
     int fileDescriptor = 0;
 
     UnixFileGuard fileHelper(deviceName, &fileDescriptor, O_RDWR,
-            "SpiComIF::initializeInterface: ");
+            "SpiComIF::initializeInterface");
     if(fileHelper.getOpenResult()) {
         sif::error << "SpiTestClass::performLis3Mdl3100Test: File descriptor could not be opened!"
                 << std::endl;
@@ -352,7 +352,7 @@ void SpiTestClass::acsInit() {
 
     gpio = new GpiodRegular(q7sGpioName5, gyro2L3gd20ChipSelect, "GYRO_2_L3G",
             gpio::Direction::OUT, gpio::HIGH);
-    gpioCookie->addGpio(gpioIds::GYRO_2_L3G_CS, gpio);
+    gpioCookie->addGpio(gpioIds::GYRO_3_L3G_CS, gpio);
 
     gpio = new GpiodRegular(q7sGpioName6, mgm2Lis3mdlChipSelect, "MGM_2_LIS3",
             gpio::Direction::OUT, gpio::HIGH);

linux/devices/SusHandler.cpp

@@ -173,7 +173,7 @@ ReturnValue_t SusHandler::interpretDeviceReply(DeviceCommandId_t id,
         dataset.ain3 = (*(packet + 8) << 8 | *(packet + 9));
         dataset.ain4 = (*(packet + 10) << 8 | *(packet + 11));
 	    dataset.ain5 = (*(packet + 12) << 8 | *(packet + 13));
-#if OBSW_VERBOSE_LEVEL >= 1 && DEBUG_SUS
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_SUS
         sif::info << "SUS object id 0x" << std::hex << this->getObjectId() << ", Temperature: "
                 << dataset.temperatureCelcius << " °C" << std::endl;
         sif::info << "SUS object id 0x" << std::hex << this->getObjectId() << ", AIN0: "

linux/fsfwconfig/FSFWConfig.h.in

@@ -72,6 +72,6 @@ static constexpr size_t FSFW_MAX_TM_PACKET_SIZE = 2048;
 
 }
 
-#define FSFW_HAL_LINUX_SPI_WIRETAPPING  1
+#define FSFW_HAL_LINUX_SPI_WIRETAPPING  0
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

linux/fsfwconfig/OBSWConfig.h.in

@@ -6,9 +6,9 @@
 #ifndef FSFWCONFIG_OBSWCONFIG_H_
 #define FSFWCONFIG_OBSWCONFIG_H_
 
-#cmakedefine RASPBERRY_PI
+/* #undef RASPBERRY_PI */
-#cmakedefine XIPHOS_Q7S
+#define XIPHOS_Q7S
-#cmakedefine BEAGLEBONEBLACK
+/* #undef BEAGLEBONEBLACK */
 
 #ifdef RASPBERRY_PI
 #include "rpiConfig.h"
@@ -22,53 +22,63 @@
 debugging. */
 #define OBSW_VERBOSE_LEVEL                          1
 
-//! Timers can mess up the code when debugging
+//! Board defines
-//! TODO: Enable for mission code, disable for debug code
+#define BOARD_TE0720                                0
-#define OBSW_ENABLE_TIMERS              0
 
-#define OBSW_PRINT_MISSED_DEADLINES     1
+/*******************************************************************/
-#define OBSW_ADD_TEST_CODE              1
+/** All of the following flags should be enabled for mission code  */
-#define OBSW_ADD_TEST_PST               1
+/*******************************************************************/
+
+//! Timers can mess up the code when debugging
+//! All of this should be enabled for mission code!
+#define OBSW_ENABLE_TIMERS                          1
 #define OBSW_ADD_GPS                                0
 #define OBSW_ADD_STAR_TRACKER                       0
+#define OBSW_ADD_PLOC_SUPERVISOR                    0
+#define OBSW_ADD_PLOC_MPSOC                         0
 
-#define TEST_LIBGPIOD                   0
+/*******************************************************************/
-#define TEST_RADIATION_SENSOR_HANDLER   0
+/** All of the following flags should be disabled for mission code */
-#define TEST_SUS_HANDLER                0
+/*******************************************************************/
-#define TEST_PLOC_HANDLER               0
-#define TEST_CCSDS_BRIDGE               0
-#define PERFORM_PTME_TEST               0
-#define ADD_PLOC_SUPERVISOR             1
-#define ADD_PLOC_MPSOC	                0
 
-#define BOARD_TE0720                    0
+//! /* Can be used to switch device to NORMAL mode immediately */
-#define TE0720_HEATER_TEST              0
+#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
+#define OBSW_PRINT_MISSED_DEADLINES                 1
+#define OBSW_ADD_TEST_CODE                          0
+#define OBSW_ADD_TEST_PST                           0
+#define OBSW_ADD_TEST_TASK                          0
+#define OBSW_TEST_LIBGPIOD                          0
+#define OBSW_TEST_RADIATION_SENSOR_HANDLER          0
+#define OBSW_TEST_SUS_HANDLER                       0
+#define OBSW_TEST_PLOC_HANDLER                      0
+#define OBSW_TEST_CCSDS_BRIDGE                      0
+#define OBSW_TEST_CCSDS_PTME                        0
+#define OBSW_TEST_TE7020_HEATER                     0
 
-#define P60DOCK_DEBUG                   0
+#define OBSW_DEBUG_P60DOCK                          0
-#define PDU1_DEBUG                      0
+#define OBSW_DEBUG_PDU1                             0
-#define PDU2_DEBUG                      0
+#define OBSW_DEBUG_PDU2                             0
-#define ACU_DEBUG                       0
+#define OBSW_DEBUG_ACU                              0
-#define SYRLINKS_DEBUG                  0
+#define OBSW_DEBUG_SYRLINKS                         0
-#define IMQT_DEBUG  				    0
+#define OBSW_DEBUG_IMQT                             0
-#define ADIS16507_DEBUG                 1
+#define OBSW_DEBUG_ADIS16507                        0
-#define L3GD20_GYRO_DEBUG               0
+#define OBSW_DEBUG_L3GD20_GYRO                      0
-#define DEBUG_RAD_SENSOR                0
+#define OBSW_DEBUG_RAD_SENSOR                       0
-#define DEBUG_SUS                       1
+#define OBSW_DEBUG_SUS                              0
-#define DEBUG_RTD                       1
+#define OBSW_DEBUG_RTD                              0
-#define IMTQ_DEBUG                      1
+#define OBSW_DEBUG_RW                               0
-#define RW_DEBUG                        0
+#define OBSW_DEBUG_STARTRACKER                      0
-#define START_TRACKER_DEBUG             0
+#define OBSW_DEBUG_PLOC_MPSOC                       0
-#define PLOC_MPSOC_DEBUG	            0
+#define OBSW_DEBUG_PLOC_SUPERVISOR                  0
-#define PLOC_SUPERVISOR_DEBUG           1
 
+/*******************************************************************/
+/** Hardcoded                                                      */
+/*******************************************************************/
 // Leave at one as the BSP is linux. Used by the ADIS16507 device handler
 #define OBSW_ADIS16507_LINUX_COM_IF     1
 
 #include "OBSWVersion.h"
 
-/* Can be used to switch device to NORMAL mode immediately */
-#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
-
 #ifdef __cplusplus
 
 #include "objects/systemObjectList.h"

linux/fsfwconfig/devices/gpioIds.h

@@ -4,7 +4,7 @@
 #include <fsfw_hal/common/gpio/GpioIF.h>
 
 namespace gpioIds {
-	enum gpioId_t {
+enum gpioId_t {
     HEATER_0,
     HEATER_1,
     HEATER_2,
@@ -20,7 +20,8 @@ namespace gpioIds {
     MGM_1_RM3100_CS,
     GYRO_0_ADIS_CS,
     GYRO_1_L3G_CS,
-		GYRO_2_L3G_CS,
+    GYRO_2_ADIS_CS,
+    GYRO_3_L3G_CS,
     MGM_2_LIS3_CS,
     MGM_3_RM3100_CS,
 
@@ -83,7 +84,7 @@ namespace gpioIds {
     EN_RW_CS,
 
     SPI_MUX
-	};
+};
 }
 
 

linux/fsfwconfig/fsfwconfig.mk

@@ -1,15 +0,0 @@
-CXXSRC += $(wildcard $(CURRENTPATH)/cdatapool/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
-
-INCLUDES += $(CURRENTPATH)
-INCLUDES += $(CURRENTPATH)/objects
-INCLUDES += $(CURRENTPATH)/ipc
-INCLUDES += $(CURRENTPATH)/pollingsequence
-INCLUDES += $(CURRENTPATH)/returnvalues
-INCLUDES += $(CURRENTPATH)/tmtc
-INCLUDES += $(CURRENTPATH)/events
-INCLUDES += $(CURRENTPATH)/devices
-INCLUDES += $(CURRENTPATH)/cdatapool

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -423,6 +423,77 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
     thisSequence->addSlot(objects::RW4, length * 0.6, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::RW4, length * 0.8, DeviceHandlerIF::GET_READ);
 
+#if OBSW_ADD_ACS_BOARD == 1
+    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0,
+            DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.2,
+            DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.4,
+            DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.6,
+            DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.8,
+            DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0,
+            DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.2,
+            DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.4,
+            DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.6,
+            DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.8,
+            DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0,
+            DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.2,
+            DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.4,
+            DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.6,
+            DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.8,
+            DeviceHandlerIF::GET_READ);
+
+
+    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0,
+            DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.2,
+            DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.4,
+            DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.6,
+            DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.8,
+            DeviceHandlerIF::GET_READ);
+
+
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0,
+            DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.2,
+            DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.4,
+            DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.6,
+            DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.8,
+            DeviceHandlerIF::GET_READ);
+
+
+    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0,
+            DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.2,
+            DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.4,
+            DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.6,
+            DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.8,
+            DeviceHandlerIF::GET_READ);
+#endif
+
     if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) {
         sif::error << "SPI PST initialization failed" << std::endl;
         return HasReturnvaluesIF::RETURN_FAILED;
@@ -449,7 +520,7 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) {
     // Length of a communication cycle
     uint32_t length = thisSequence->getPeriodMs();
 
-#if ADD_PLOC_MPSOC == 1
+#if OBSW_ADD_PLOC_MPSOC == 1
     thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0,
             DeviceHandlerIF::PERFORM_OPERATION);
     thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.2,
@@ -462,7 +533,7 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) {
                 DeviceHandlerIF::GET_READ);
 #endif
 
-#if ADD_PLOC_SUPERVISOR == 1
+#if OBSW_ADD_PLOC_SUPERVISOR == 1
     thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0,
             DeviceHandlerIF::PERFORM_OPERATION);
     thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.2,
@@ -655,15 +726,15 @@ ReturnValue_t pst::pstTest(FixedTimeslotTaskIF* thisSequence) {
             DeviceHandlerIF::GET_READ);
 
 
-    thisSequence->addSlot(objects::GYRO_2_L3G_HANDLER, length * 0,
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0,
             DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_2_L3G_HANDLER, length * 0.2,
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.2,
             DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::GYRO_2_L3G_HANDLER, length * 0.4,
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.4,
             DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_2_L3G_HANDLER, length * 0.6,
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.6,
             DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::GYRO_2_L3G_HANDLER, length * 0.8,
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.8,
             DeviceHandlerIF::GET_READ);
 
 
@@ -722,7 +793,7 @@ ReturnValue_t pst::pollingSequenceTE0720(FixedTimeslotTaskIF *thisSequence) {
     thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
 #endif
 
-#if TEST_RADIATION_SENSOR_HANDLER == 1
+#if OBSW_TEST_RADIATION_SENSOR_HANDLER == 1
     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);
@@ -730,7 +801,7 @@ ReturnValue_t pst::pollingSequenceTE0720(FixedTimeslotTaskIF *thisSequence) {
     thisSequence->addSlot(objects::RAD_SENSOR, length * 0.8, DeviceHandlerIF::GET_READ);
 #endif
 
-#if TEST_SUS_HANDLER == 1
+#if OBSW_TEST_SUS_HANDLER == 1
     /* Write setup */
     thisSequence->addSlot(objects::SUS_1, length * 0.901, DeviceHandlerIF::PERFORM_OPERATION);
     thisSequence->addSlot(objects::SUS_1, length * 0.902, SusHandler::FIRST_WRITE);
@@ -753,7 +824,7 @@ ReturnValue_t pst::pollingSequenceTE0720(FixedTimeslotTaskIF *thisSequence) {
     thisSequence->addSlot(objects::SUS_1, length * 0.915, DeviceHandlerIF::GET_READ);
 #endif
 
-#if ADD_PLOC_SUPERVISOR == 1
+#if OBSW_ADD_PLOC_SUPERVISOR == 1
     thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
     thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
     thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);

linux/obc/CCSDSIPCoreBridge.cpp

@@ -39,7 +39,7 @@ ReturnValue_t CCSDSIPCoreBridge::initialize() {
 
 ReturnValue_t CCSDSIPCoreBridge::handleTm() {
 
-#if PERFORM_PTME_TEST == 1
+#if OBSW_TEST_CCSDS_PTME == 1
     return sendTestFrame();
 #else
     return TmTcBridge::handleTm();

mission/devices/ACUHandler.cpp

@@ -21,7 +21,7 @@ void ACUHandler::letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *pack
     parseHkTableReply(packet);
     handleDeviceTM(&acuHkTableDataset, id, true);
 
-#if OBSW_ENHANCED_PRINTOUT == 1 && ACU_DEBUG == 1
+#if OBSW_ENHANCED_PRINTOUT == 1 && OBSW_DEBUG_ACU == 1
     acuHkTableDataset.read();
     float temperatureC_1 = acuHkTableDataset.temperature1.value * 0.1;
     float temperatureC_2 = acuHkTableDataset.temperature2.value * 0.1;

mission/devices/GyroADIS16507Handler.cpp

@@ -16,7 +16,7 @@ GyroADIS16507Handler::GyroADIS16507Handler(object_id_t objectId,
         object_id_t deviceCommunication, CookieIF * comCookie):
         DeviceHandlerBase(objectId, deviceCommunication, comCookie), primaryDataset(this),
         configDataset(this), breakCountdown() {
-#if ADIS16507_DEBUG == 1
+#if OBSW_DEBUG_ADIS16507 == 1
     debugDivider = new PeriodicOperationDivider(5);
 #endif
 
@@ -284,7 +284,7 @@ ReturnValue_t GyroADIS16507Handler::handleSensorData(const uint8_t *packet) {
             primaryDataset.setValidity(true, true);
         }
 
-#if ADIS16507_DEBUG == 1
+#if OBSW_DEBUG_ADIS16507 == 1
         if(debugDivider->checkAndIncrement()) {
             sif::info << "GyroADIS16507Handler: Angular velocities in deg / s" << std::endl;
             sif::info << "X: " << primaryDataset.angVelocX.value << std::endl;
@@ -393,7 +393,7 @@ ReturnValue_t GyroADIS16507Handler::spiSendCallback(SpiComIF *comIf, SpiCookie *
         // Prepare transfer
         int fileDescriptor = 0;
         std::string device = cookie->getSpiDevice();
-        UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage: ");
+        UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
         if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
             return SpiComIF::OPENING_FILE_FAILED;
         }

mission/devices/GyroADIS16507Handler.h

@@ -69,7 +69,7 @@ private:
             const uint8_t *sendData, size_t sendLen, void* args);
 #endif
 
-#if ADIS16507_DEBUG == 1
+#if OBSW_DEBUG_ADIS16507 == 1
     PeriodicOperationDivider* debugDivider;
 #endif
     Countdown breakCountdown;

mission/devices/IMTQHandler.cpp

@@ -683,7 +683,7 @@ void IMTQHandler::fillEngHkDataset(const uint8_t* packet) {
     offset += 2;
     engHkDataset.mcuTemperature = (*(packet + offset + 1) << 8 | *(packet + offset));
 
-#if OBSW_VERBOSE_LEVEL >= 1 && IMTQ_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_IMTQ  == 1
     sif::info << "IMTQ digital voltage: " << engHkDataset.digitalVoltageMv << " mV" << std::endl;
     sif::info << "IMTQ analog voltage: " << engHkDataset.analogVoltageMv << " mV" << std::endl;
     sif::info << "IMTQ digital current: " << engHkDataset.digitalCurrentmA << " mA" << std::endl;
@@ -757,7 +757,7 @@ void IMTQHandler::fillCalibratedMtmDataset(const uint8_t* packet) {
     offset += 4;
     calMtmMeasurementSet.coilActuationStatus = (*(packet + offset + 3) << 24)
             | (*(packet + offset + 2) << 16) | (*(packet + offset + 1) << 8) | (*(packet + offset));
-#if OBSW_VERBOSE_LEVEL >= 1 && IMTQ_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_IMTQ  == 1
     sif::info << "IMTQ calibrated MTM measurement X: " << calMtmMeasurementSet.mtmXnT << " nT"
             << std::endl;
     sif::info << "IMTQ calibrated MTM measurement Y: " << calMtmMeasurementSet.mtmYnT << " nT"
@@ -783,7 +783,7 @@ void IMTQHandler::fillRawMtmDataset(const uint8_t* packet) {
     offset += 4;
     rawMtmMeasurementSet.coilActuationStatus = (*(packet + offset + 3) << 24)
             | (*(packet + offset + 2) << 16) | (*(packet + offset + 1) << 8) | (*(packet + offset));
-#if OBSW_VERBOSE_LEVEL >= 1 && IMTQ_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_IMTQ  == 1
     sif::info << "IMTQ raw MTM measurement X: " << rawMtmMeasurementSet.mtmXnT << " nT"
             << std::endl;
     sif::info << "IMTQ raw MTM measurement Y: " << rawMtmMeasurementSet.mtmYnT << " nT"
@@ -946,7 +946,7 @@ void IMTQHandler::handlePositiveXSelfTestReply(const uint8_t* packet) {
     posXselfTestDataset.finaCoilZTemperature = *(packet + offset + 1) << 8 | *(packet + offset);
     offset += 4;
 
-#if OBSW_VERBOSE_LEVEL >= 1 && IMTQ_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_IMTQ  == 1
     sif::info << "IMTQ self test (INIT) err: "
             << static_cast<unsigned int>(posXselfTestDataset.initErr.value) << std::endl;
     sif::info << "IMTQ self test (INIT) raw magnetic field X: " << posXselfTestDataset.initRawMagX
@@ -1147,7 +1147,7 @@ void IMTQHandler::handleNegativeXSelfTestReply(const uint8_t* packet) {
     negXselfTestDataset.finaCoilZTemperature = *(packet + offset + 1) << 8 | *(packet + offset);
     offset += 4;
 
-#if OBSW_VERBOSE_LEVEL >= 1 && IMTQ_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_IMTQ  == 1
     sif::info << "IMTQ self test (INIT) err: "
             << static_cast<unsigned int>(negXselfTestDataset.initErr.value) << std::endl;
     sif::info << "IMTQ self test (INIT) raw magnetic field X: " << negXselfTestDataset.initRawMagX
@@ -1348,7 +1348,7 @@ void IMTQHandler::handlePositiveYSelfTestReply(const uint8_t* packet) {
     posYselfTestDataset.finaCoilZTemperature = *(packet + offset + 1) << 8 | *(packet + offset);
     offset += 4;
 
-#if OBSW_VERBOSE_LEVEL >= 1 && IMTQ_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_IMTQ  == 1
     sif::info << "IMTQ self test (INIT) err: "
             << static_cast<unsigned int>(posYselfTestDataset.initErr.value) << std::endl;
     sif::info << "IMTQ self test (INIT) raw magnetic field X: " << posYselfTestDataset.initRawMagX
@@ -1549,7 +1549,7 @@ void IMTQHandler::handleNegativeYSelfTestReply(const uint8_t* packet) {
     negYselfTestDataset.finaCoilZTemperature = *(packet + offset + 1) << 8 | *(packet + offset);
     offset += 4;
 
-#if OBSW_VERBOSE_LEVEL >= 1 && IMTQ_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_IMTQ  == 1
     sif::info << "IMTQ self test (INIT) err: "
             << static_cast<unsigned int>(negYselfTestDataset.initErr.value) << std::endl;
     sif::info << "IMTQ self test (INIT) raw magnetic field X: " << negYselfTestDataset.initRawMagX
@@ -1750,7 +1750,7 @@ void IMTQHandler::handlePositiveZSelfTestReply(const uint8_t* packet) {
     posZselfTestDataset.finaCoilZTemperature = *(packet + offset + 1) << 8 | *(packet + offset);
     offset += 4;
 
-#if OBSW_VERBOSE_LEVEL >= 1 && IMTQ_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_IMTQ  == 1
     sif::info << "IMTQ self test (INIT) err: "
             << static_cast<unsigned int>(posZselfTestDataset.initErr.value) << std::endl;
     sif::info << "IMTQ self test (INIT) raw magnetic field X: " << posZselfTestDataset.initRawMagX
@@ -1951,7 +1951,7 @@ void IMTQHandler::handleNegativeZSelfTestReply(const uint8_t* packet) {
     negZselfTestDataset.finaCoilZTemperature = *(packet + offset + 1) << 8 | *(packet + offset);
     offset += 4;
 
-#if OBSW_VERBOSE_LEVEL >= 1 && IMTQ_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_IMTQ  == 1
     sif::info << "IMTQ self test (INIT) err: "
             << static_cast<unsigned int>(negZselfTestDataset.initErr.value) << std::endl;
     sif::info << "IMTQ self test (INIT) raw magnetic field X: " << negZselfTestDataset.initRawMagX

mission/devices/Max31865PT1000Handler.cpp

@@ -325,7 +325,7 @@ ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(
     case(Max31865Definitions::REQUEST_LOW_THRESHOLD): {
         uint16_t readLowThreshold = packet[0] << 8 | packet[1];
         if(readLowThreshold != LOW_THRESHOLD) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && DEBUG_RTD == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && OBSW_DEBUG_RTD == 1
             sif::error
                     << "Max31865PT1000Handler::interpretDeviceReply: Missmatch between written "
                     << "and readback value of low threshold register"
@@ -338,7 +338,7 @@ ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(
     case(Max31865Definitions::REQUEST_HIGH_THRESHOLD): {
         uint16_t readHighThreshold = packet[0] << 8 | packet[1];
         if(readHighThreshold != HIGH_THRESHOLD) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && DEBUG_RTD == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && OBSW_DEBUG_RTD == 1
             sif::error
                     << "Max31865PT1000Handler::interpretDeviceReply: Missmatch between written "
                     << "and readback value of high threshold register"

mission/devices/P60DockHandler.cpp

@@ -25,7 +25,7 @@ void P60DockHandler::letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *
      */
     handleDeviceTM(&p60dockHkTableDataset, id, true);
 
-#if OBSW_VERBOSE_LEVEL >= 1 && P60DOCK_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_P60DOCK == 1
     p60dockHkTableDataset.read();
     sif::info << "P60 Dock: ACU VCC switch: " << static_cast<unsigned int>(p60dockHkTableDataset.outputEnableStateAcuVcc.value) << std::endl;
     sif::info << "P60 Dock: PDU1 VCC switch: " << static_cast<unsigned int>(p60dockHkTableDataset.outputEnableStatePdu1Vcc.value) << std::endl;

mission/devices/PDU1Handler.cpp

@@ -22,7 +22,7 @@ void PDU1Handler::letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *pac
     parseHkTableReply(packet);
     handleDeviceTM(&pdu1HkTableDataset, id, true);
 
-#if OBSW_VERBOSE_LEVEL >= 1 && PDU1_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PDU1 == 1
     pdu1HkTableDataset.read();
     sif::info << "PDU1 TCS Board voltage: " << pdu1HkTableDataset.voltageOutTCSBoard3V3
             << std::endl;

mission/devices/PDU2Handler.cpp

@@ -26,7 +26,7 @@ void PDU2Handler::letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *pac
      */
     handleDeviceTM(&pdu2HkTableDataset, id, true);
 
-#if OBSW_VERBOSE_LEVEL >= 1 && PDU2_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PDU2 == 1
     pdu2HkTableDataset.read();
     sif::info << "PDU2 Q7S current voltage: " << pdu2HkTableDataset.voltageOutQ7S << " mV" << std::endl;
     sif::info << "PDU2 VCC: " << pdu2HkTableDataset.vcc << " mV" << std::endl;

mission/devices/RadiationSensorHandler.cpp

@@ -147,7 +147,7 @@ ReturnValue_t RadiationSensorHandler::interpretDeviceReply(DeviceCommandId_t id,
         offset += 2;
         dataset.ain7 = (*(packet + offset) << 8 | *(packet + offset + 1));
 
-#if OBSW_VERBOSE_LEVEL >= 1 && DEBUG_RAD_SENSOR
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_RAD_SENSOR
         sif::info << "Radiation sensor temperature: " << dataset.temperatureCelcius << " °C"
                 << std::endl;
         sif::info << "Radiation sensor ADC value channel 0: " << dataset.ain0

mission/devices/RwHandler.cpp

@@ -347,7 +347,7 @@ void RwHandler::handleResetStatusReply(const uint8_t* packet) {
         lastResetStatusSet.lastResetStatus = resetStatus;
     }
     lastResetStatusSet.currentResetStatus = resetStatus;
-#if OBSW_VERBOSE_LEVEL >= 1 && RW_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_RW == 1
     sif::info << "RwHandler::handleResetStatusReply: Last reset status: "
             << static_cast<unsigned int>(lastResetStatusSet.lastResetStatus.value) << std::endl;
     sif::info << "RwHandler::handleResetStatusReply: Current reset status: "
@@ -378,7 +378,7 @@ void RwHandler::handleGetRwStatusReply(const uint8_t* packet) {
                 << std::endl;
     }
 
-#if OBSW_VERBOSE_LEVEL >= 1 && RW_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_RW == 1
     sif::info << "RwHandler::handleGetRwStatusReply: Current speed is: " << statusSet.currSpeed
             << " * 0.1 RPM" << std::endl;
     sif::info << "RwHandler::handleGetRwStatusReply: Reference speed is: "
@@ -395,7 +395,7 @@ void RwHandler::handleTemperatureReply(const uint8_t* packet) {
     uint8_t offset = 2;
     temperatureSet.temperatureCelcius = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16
             | *(packet + offset + 1) << 8 | *(packet + offset);
-#if OBSW_VERBOSE_LEVEL >= 1 && RW_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_RW == 1
     sif::info << "RwHandler::handleTemperatureReply: Temperature: "
             << temperatureSet.temperatureCelcius << " °C" << std::endl;
 #endif
@@ -472,7 +472,7 @@ void RwHandler::handleGetTelemetryReply(const uint8_t* packet) {
     offset += 4;
     tmDataset.spiTotalNumOfErrors = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16
                 | *(packet + offset + 1) << 8 | *(packet + offset);
-#if OBSW_VERBOSE_LEVEL >= 1 && RW_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_RW == 1
     sif::info << "RwHandler::handleTemperatureReply: Last reset status: "
             << static_cast<unsigned int>(tmDataset.lastResetStatus.value) << std::endl;
     sif::info << "RwHandler::handleTemperatureReply: MCU temperature: " << tmDataset.mcuTemperature

mission/devices/StarTrackerHandler.cpp

@@ -207,7 +207,7 @@ void StarTrackerHandler::handleTemperatureTm() {
     temperatureSet.cmosTemperature = *(decodedFrame + offset) << 24
             | *(decodedFrame + offset + 1) << 16 | *(decodedFrame + offset + 2) << 8
             | *(decodedFrame + offset + 3);
-#if OBSW_VERBOSE_LEVEL >= 1 && START_TRACKER_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1
     sif::info << "StarTrackerHandler::handleTemperatureTm: MCU Temperature: "
             << temperatureSet.mcuTemperature << " °C" << std::endl;
     sif::info << "StarTrackerHandler::handleTemperatureTm: CMOS Temperature: "

mission/devices/SyrlinksHkHandler.cpp

@@ -384,7 +384,7 @@ void SyrlinksHkHandler::parseRxStatusRegistersReply(const uint8_t* packet) {
     offset += 6;
     rxDataset.rxDataRate = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
 
-#if OBSW_VERBOSE_LEVEL >= 1 && SYRLINKS_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_SYRLINKS == 1
     sif::info << "Syrlinks RX Status: 0x" << std::hex << (unsigned int)rxDataset.rxStatus.value << std::endl;
     sif::info << "Syrlinks RX Sensitivity: " << std::dec << rxDataset.rxSensitivity << std::endl;
     sif::info << "Syrlinks RX Frequency Shift: " << rxDataset.rxFrequencyShift << std::endl;
@@ -400,7 +400,7 @@ void SyrlinksHkHandler::parseTxStatusReply(const uint8_t* packet) {
     PoolReadGuard readHelper(&txDataset);
     uint16_t offset = SYRLINKS::MESSAGE_HEADER_SIZE;
     txDataset.txStatus = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
-#if OBSW_VERBOSE_LEVEL >= 1 && SYRLINKS_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_SYRLINKS == 1
     sif::info << "Syrlinks TX Status: 0x" << std::hex << (unsigned int) txDataset.txStatus.value
             << std::endl;
 #endif
@@ -410,7 +410,7 @@ void SyrlinksHkHandler::parseTxWaveformReply(const uint8_t* packet) {
     PoolReadGuard readHelper(&txDataset);
     uint16_t offset = SYRLINKS::MESSAGE_HEADER_SIZE;
     txDataset.txWaveform = convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
-#if OBSW_VERBOSE_LEVEL >= 1 && SYRLINKS_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_SYRLINKS == 1
     sif::info << "Syrlinks TX Waveform: 0x" << std::hex << (unsigned int) txDataset.txWaveform.value
             << std::endl;
 #endif
@@ -420,7 +420,7 @@ void SyrlinksHkHandler::parseAgcLowByte(const uint8_t* packet) {
     PoolReadGuard readHelper(&txDataset);
     uint16_t offset = SYRLINKS::MESSAGE_HEADER_SIZE;
     txDataset.txAgcValue = agcValueHighByte << 8 | convertHexStringToUint8(reinterpret_cast<const char*>(packet + offset));
-#if OBSW_VERBOSE_LEVEL >= 1 && SYRLINKS_DEBUG == 1
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_SYRLINKS == 1
     sif::info << "Syrlinks TX AGC Value: " << txDataset.txAgcValue << std::endl;
 #endif
 }