merged mueller master

.gitmodules

@@ -13,3 +13,6 @@
 [submodule "thirdparty/lwgps"]
 	path = thirdparty/lwgps
 	url = https://github.com/rmspacefish/lwgps.git
+[submodule "fsfw_hal"]
+	path = fsfw_hal
+	url = https://egit.irs.uni-stuttgart.de/fsfw/fsfw_hal.git

CMakeLists.txt

@@ -40,6 +40,7 @@ set(TARGET_NAME ${CMAKE_PROJECT_NAME})
 set(LIB_FSFW_NAME fsfw)
 set(LIB_ETL_NAME etl)
 set(LIB_CSP_NAME libcsp)
+set(LIB_FSFW_HAL_NAME fsfw_hal)
 set(LIB_LWGPS_NAME lwgps)
 set(THIRD_PARTY_FOLDER thirdparty)
 
@@ -50,6 +51,7 @@ set(TEST_PATH test/testtasks)
 set(LINUX_PATH linux)
 set(COMMON_PATH common)
 
+set(FSFW_HAL_LIB_PATH fsfw_hal)
 set(CSP_LIB_PATH ${THIRD_PARTY_FOLDER}/libcsp)
 set(ETL_LIB_PATH ${THIRD_PARTY_FOLDER}/etl)
 set(LWGPS_LIB_PATH ${THIRD_PARTY_FOLDER}/lwgps)
@@ -68,10 +70,12 @@ if(TGT_BSP)
         set(FSFW_CONFIG_PATH "fsfwconfig")
         set(ADD_LINUX_FILES TRUE)
         set(ADD_CSP_LIB TRUE)
+        set(FSFW_HAL_ADD_LINUX ON)
     endif()
    
     if(${TGT_BSP} MATCHES "arm/raspberrypi") 
         add_definitions(-DRASPBERRY_PI)
+        set(FSFW_HAL_ADD_RASPBERRY_PI ON)
     endif()
     
     if(${TGT_BSP} MATCHES "arm/q7s")
@@ -113,6 +117,7 @@ add_subdirectory(${BSP_PATH})
 add_subdirectory(${FSFW_PATH})
 add_subdirectory(${MISSION_PATH})
 add_subdirectory(${TEST_PATH})
+add_subdirectory(${FSFW_HAL_LIB_PATH})
 add_subdirectory(${COMMON_PATH})
 
 ################################################################################
@@ -126,6 +131,7 @@ target_link_libraries(${TARGET_NAME} PRIVATE
 	${LIB_FSFW_NAME} 
 	${LIB_OS_NAME} 
 	${LIB_LWGPS_NAME}
+	${LIB_FSFW_HAL_NAME}
 )
 
 if(ADD_ETL_LIB)

bsp_hosted/ObjectFactory.cpp

@@ -11,13 +11,8 @@
 #include <mission/core/GenericFactory.h>
 #include <mission/utility/TmFunnel.h>
 
-#ifdef LINUX
+#include <fsfw/osal/common/UdpTcPollingTask.h>
-#include <fsfw/osal/linux/TcUnixUdpPollingTask.h>
+#include <fsfw/osal/common/UdpTmTcBridge.h>
-#include <fsfw/osal/linux/TmTcUnixUdpBridge.h>
-#elif WIN32
-#include <fsfw/osal/windows/TcWinUdpPollingTask.h>
-#include <fsfw/osal/windows/TmTcWinUdpBridge.h>
-#endif
 
 #include <fsfw/tmtcpacket/pus/TmPacketStored.h>
 
@@ -45,17 +40,9 @@ void ObjectFactory::produce(){
 	Factory::setStaticFrameworkObjectIds();
 	ObjectFactory::produceGenericObjects();
 
-#ifdef LINUX
+    new UdpTmTcBridge(objects::UDP_BRIDGE,
-    new TmTcUnixUdpBridge(objects::UDP_BRIDGE,
             objects::CCSDS_PACKET_DISTRIBUTOR,
             objects::TM_STORE, objects::TC_STORE);
-    new TcUnixUdpPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
+    new UdpTcPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
-#elif WIN32
-    new TmTcWinUdpBridge(objects::UDP_BRIDGE,
-            objects::CCSDS_PACKET_DISTRIBUTOR, objects::TM_STORE,
-            objects::TC_STORE);
-    new TcWinUdpPollingTask(objects::UDP_POLLING_TASK,
-            objects::UDP_BRIDGE);
-#endif
 
 }

bsp_q7s/InitMission.cpp

@@ -137,6 +137,7 @@ void initmission::initTasks() {
 
     //TODO: Add handling of missed deadlines
     /* Polling Sequence Table Default */
+#if Q7S_ADD_SPI_TEST == 0
     FixedTimeslotTaskIF * pollingSequenceTableTaskDefault = factory->createFixedTimeslotTask(
             "PST_TASK_DEFAULT", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0,
             missedDeadlineFunc);
@@ -144,6 +145,7 @@ void initmission::initTasks() {
     if (result != HasReturnvaluesIF::RETURN_OK) {
         sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
     }
+#endif
 
 #if TE0720 == 0
     FixedTimeslotTaskIF* gomSpacePstTask = factory->
@@ -155,13 +157,20 @@ void initmission::initTasks() {
     }
 #endif
 
-    PeriodicTaskIF* testTask = factory->createPeriodicTask(
-            "GPIOD_TEST", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1, missedDeadlineFunc);
 #if OBSW_ADD_TEST_CODE == 1
+    PeriodicTaskIF* testTask = factory->createPeriodicTask(
+            "TEST_TASK", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1, missedDeadlineFunc);
     result = testTask->addComponent(objects::TEST_TASK);
     if(result != HasReturnvaluesIF::RETURN_OK) {
         initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
     }
+
+#if Q7S_ADD_SPI_TEST == 1
+    result = testTask->addComponent(objects::SPI_TEST);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
+    }
+#endif
 #endif /* OBSW_ADD_TEST_CODE == 1 */
 #if TE0720 == 1 && TEST_LIBGPIOD == 1
     result = testTask->addComponent(objects::LIBGPIOD_TEST);
@@ -178,7 +187,10 @@ void initmission::initTasks() {
 #if TE0720 == 0
     gomSpacePstTask->startTask();
 #endif
+
+#if Q7S_ADD_SPI_TEST == 0
     pollingSequenceTableTaskDefault->startTask();
+#endif
 
     pusVerification->startTask();
     pusEvents->startTask();
@@ -186,6 +198,8 @@ void initmission::initTasks() {
     pusMedPrio->startTask();
     pusLowPrio->startTask();
 
+#if OBSW_ADD_TEST_CODE == 1
     testTask->startTask();
+#endif
     sif::info << "Tasks started.." << std::endl;
 }

bsp_q7s/ObjectFactory.cpp

@@ -5,6 +5,7 @@
 #include <devices/gpioIds.h>
 #include <tmtc/pusIds.h>
 #include <devices/powerSwitcherList.h>
+#include <devices/spi.h>
 
 #include <bsp_q7s/devices/HeaterHandler.h>
 #include <bsp_q7s/devices/SolarArrayDeploymentHandler.h>
@@ -21,6 +22,9 @@
 #include <mission/devices/IMTQHandler.h>
 #include <mission/devices/devicedefinitions/Max31865Definitions.h>
 #include <mission/devices/SyrlinksHkHandler.h>
+#include <mission/devices/MGMHandlerLIS3MDL.h>
+#include <mission/devices/MGMHandlerRM3100.h>
+#include <mission/devices/GyroL3GD20Handler.h>
 
 #include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
 #include <mission/devices/devicedefinitions/SyrlinksDefinitions.h>
@@ -28,25 +32,26 @@
 
 #include <linux/csp/CspCookie.h>
 #include <linux/csp/CspComIF.h>
-#include <linux/i2c/I2cCookie.h>
+
-#include <linux/i2c/I2cComIF.h>
-#include <linux/gpio/LinuxLibgpioIF.h>
-#include <linux/gpio/GpioCookie.h>
 #include <linux/uart/UartComIF.h>
 #include <linux/uart/UartCookie.h>
-#include <linux/spi/SpiComIF.h>
+
-#include <linux/spi/SpiCookie.h>
+#include <fsfw_hal/linux/i2c/I2cCookie.h>
+#include <fsfw_hal/linux/i2c/I2cComIF.h>
+#include <fsfw_hal/linux/spi/SpiCookie.h>
+#include <fsfw_hal/linux/spi/SpiComIF.h>
+#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
 
 #include <fsfw/datapoollocal/LocalDataPoolManager.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
 #include <fsfw/tmtcpacket/pus/TmPacketStored.h>
+
+/* UDP server includes */
+#include <fsfw/osal/common/UdpTmTcBridge.h>
 #include <fsfw/osal/common/UdpTcPollingTask.h>
-
+#include <linux/boardtest/SpiTestClass.h>
-#include <fsfw/datapoollocal/LocalDataPoolManager.h>
-#include <fsfw/tmtcservices/CommandingServiceBase.h>
-#include <fsfw/tmtcservices/PusServiceBase.h>
-#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
 
 #if TEST_LIBGPIOD == 1
 #include <linux/boardtest/LibgpiodTest.h>
@@ -92,7 +97,21 @@ void ObjectFactory::produce(){
     new CspComIF(objects::CSP_COM_IF);
     new I2cComIF(objects::I2C_COM_IF);
     new UartComIF(objects::UART_COM_IF);
+#if Q7S_ADD_SPI_TEST == 0
     new SpiComIF(objects::SPI_COM_IF, gpioComIF);
+#endif
+
+    /* Temperature sensors */
+    Tmp1075Handler* tmp1075Handler_1 = new Tmp1075Handler(
+            objects::TMP1075_HANDLER_1, objects::I2C_COM_IF,
+            i2cCookieTmp1075tcs1);
+    tmp1075Handler_1->setStartUpImmediately();
+    Tmp1075Handler* tmp1075Handler_2 = new Tmp1075Handler(
+            objects::TMP1075_HANDLER_2, objects::I2C_COM_IF,
+            i2cCookieTmp1075tcs2);
+    tmp1075Handler_2->setStartUpImmediately();
+
+    GpioCookie* heaterGpiosCookie = new GpioCookie;
 
 #if TE0720 == 0
     CspCookie* p60DockCspCookie = new CspCookie(P60Dock::MAX_REPLY_LENGTH,
@@ -123,19 +142,68 @@ void ObjectFactory::produce(){
 //    pdu1handler->setModeNormal();
 //    pdu2handler->setModeNormal();
 //    acuhandler->setModeNormal();
-#endif
+    (void) p60dockhandler;
-    /* Temperature sensors */
+    (void) pdu1handler;
-    Tmp1075Handler* tmp1075Handler_1 = new Tmp1075Handler(
+    (void) pdu2handler;
-            objects::TMP1075_HANDLER_1, objects::I2C_COM_IF,
+    (void) acuhandler;
-            i2cCookieTmp1075tcs1);
+
-    tmp1075Handler_1->setStartUpImmediately();
+#if OBSW_ADD_ACS_BOARD == 1
-    Tmp1075Handler* tmp1075Handler_2 = new Tmp1075Handler(
+    GpioCookie* gpioCookieAcsBoard = new GpioCookie();
-            objects::TMP1075_HANDLER_2, objects::I2C_COM_IF,
+    GpiodRegular* gpio = nullptr;
-            i2cCookieTmp1075tcs2);
+    gpio = new GpiodRegular(std::string("gpiochip5"), 1, std::string("CS_GYRO_1_ADIS"),
-    tmp1075Handler_2->setStartUpImmediately();
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio);
+    gpio = new GpiodRegular(std::string("gpiochip5"), 7, std::string("CS_GYRO_2_L3G"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::GYRO_1_L3G_CS, gpio);
+    gpio = new GpiodRegular(std::string("gpiochip5"), 3, std::string("CS_GYRO_3_L3G"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_L3G_CS, gpio);
+
+    gpio = new GpiodRegular(std::string("gpiochip5"), 5, std::string("CS_MGM_0_LIS3_A"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::MGM_0_LIS3_CS, gpio);
+
+    gpio = new GpiodRegular(std::string("gpiochip5"), 17, std::string("CS_MGM_1_RM3100_A"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::MGM_1_RM3100_CS, gpio);
+
+    gpio = new GpiodRegular(std::string("gpiochip6"), 0, std::string("CS_MGM_2_LIS3_B"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::MGM_2_LIS3_CS, gpio);
+
+    gpio = new GpiodRegular(std::string("gpiochip5"), 10, std::string("CS_MGM_3_RM3100_B"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::MGM_3_RM3100_CS, gpio);
+
+    gpioComIF->addGpios(gpioCookieAcsBoard);
+
+    std::string spiDev = "/dev/spidev2.0";
+    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,
+            objects::SPI_COM_IF, spiCookie);
+    mgmLis3Handler->setStartUpImmediately();
+
+    spiCookie = new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, spiDev,
+            MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
+    auto mgmLis3Handler2 = new MGMHandlerLIS3MDL(objects::MGM_2_LIS3_HANDLER,
+            objects::SPI_COM_IF, spiCookie);
+    mgmLis3Handler2->setStartUpImmediately();
+
+    spiCookie = new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, spiDev,
+            RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
+    auto mgmRm3100Handler = new MGMHandlerRM3100(objects::MGM_1_RM3100_HANDLER,
+            objects::SPI_COM_IF, spiCookie);
+    mgmRm3100Handler->setStartUpImmediately();
+
+    spiCookie = new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, spiDev,
+            L3GD20H::MAX_BUFFER_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+    auto gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_1_L3G_HANDLER, objects::SPI_COM_IF,
+            spiCookie);
+    gyroL3gHandler->setStartUpImmediately();
+#endif
 
-    GpioCookie* heaterGpiosCookie = new GpioCookie;
-#if TE0720 == 0
     /* Pin H2-11 on stack connector */
     GpiodRegular* gpioConfigHeater0 = new GpiodRegular(std::string("gpiochip7"), 6,
             std::string("Heater0"), gpio::OUT, 0);
@@ -196,6 +264,7 @@ void ObjectFactory::produce(){
             objects::UART_COM_IF, syrlinksUartCookie);
     syrlinksHkHandler->setModeNormal();
 
+#if Q7S_ADD_SPI_TEST == 0
     GpioCookie* rtdGpioCookie = new GpioCookie;
 
     gpioCallbacks::initTcsBoardDecoder(gpioComIF);
@@ -318,17 +387,19 @@ void ObjectFactory::produce(){
 //    rtdIc10->setStartUpImmediately();
 //    rtdIc4->setStartUpImmediately();
 
-    I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE,
+#endif /* Q7S_ADD_SPI_TEST == 0 */
-            std::string("/dev/i2c-0"));
-    IMTQHandler* imtqHandler = new IMTQHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie);
-    imtqHandler->setStartUpImmediately();
 
-#endif
+#endif /* TE0720 == 0 */
 
     new UdpTmTcBridge(objects::UDP_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR, objects::TM_STORE,
             objects::TC_STORE);
     new UdpTcPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
 
+    I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE,
+            std::string("/dev/i2c-0"));
+    IMTQHandler* imtqHandler = new IMTQHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie);
+    imtqHandler->setStartUpImmediately();
+
 #if TE0720 == 1 && TEST_LIBGPIOD == 1
     /* Configure MIO0 as input */
     GpiodRegular gpioConfigMio0(std::string("gpiochip0"), 0,
@@ -344,4 +415,8 @@ void ObjectFactory::produce(){
     new HeaterHandler(objects::HEATER_HANDLER, objects::GPIO_IF, heaterGpiosCookie,
             objects::PCDU_HANDLER, pcduSwitches::TCS_BOARD_8V_HEATER_IN);
 #endif
+
+#if Q7S_ADD_SPI_TEST == 1
+    new SpiTestClass(objects::SPI_TEST, gpioComIF);
+#endif
 }

bsp_q7s/boardconfig/q7s_config.h

@@ -0,0 +1,11 @@
+#ifndef BSP_Q7S_BOARDCONFIG_Q7S_CONFIG_H_
+#define BSP_Q7S_BOARDCONFIG_Q7S_CONFIG_H_
+
+/* Only one of those 2 should be enabled! */
+/* Add code for ACS board */
+#define OBSW_ADD_ACS_BOARD              0
+#define Q7S_ADD_SPI_TEST                0
+
+
+
+#endif /* BSP_Q7S_BOARDCONFIG_Q7S_CONFIG_H_ */

bsp_q7s/devices/HeaterHandler.cpp

@@ -2,7 +2,7 @@
 #include <fsfwconfig/devices/powerSwitcherList.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <devices/gpioIds.h>
-#include <linux/gpio/GpioCookie.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
 
 HeaterHandler::HeaterHandler(object_id_t setObjectId_, object_id_t gpioDriverId_,
         CookieIF * gpioCookie_, object_id_t mainLineSwitcherObjectId_, uint8_t mainLineSwitch_) :

bsp_q7s/devices/HeaterHandler.h

@@ -10,7 +10,7 @@
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
 #include <fsfw/devicehandlers/CookieIF.h>
 #include <fsfw/timemanager/Countdown.h>
-#include <linux/gpio/GpioIF.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
 #include <unordered_map>
 
 /**

bsp_q7s/devices/SolarArrayDeploymentHandler.cpp

@@ -3,7 +3,7 @@
 #include <devices/powerSwitcherList.h>
 #include <devices/gpioIds.h>
 
-#include <linux/gpio/GpioCookie.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
 #include <fsfw/ipc/QueueFactory.h>
 
 

bsp_q7s/devices/SolarArrayDeploymentHandler.h

@@ -1,8 +1,6 @@
 #ifndef MISSION_DEVICES_SOLARARRAYDEPLOYMENT_H_
 #define MISSION_DEVICES_SOLARARRAYDEPLOYMENT_H_
 
-#include <linux/gpio/GpioIF.h>
-
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/tasks/ExecutableObjectIF.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
@@ -11,7 +9,7 @@
 #include <fsfw/devicehandlers/CookieIF.h>
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
 #include <fsfw/timemanager/Countdown.h>
-
+#include <fsfw_hal/common/gpio/GpioIF.h>
 #include <unordered_map>
 
 /**

bsp_q7s/gpio/gpioCallbacks.cpp

@@ -1,7 +1,8 @@
-#include <bsp_q7s/gpio/gpioCallbacks.h>
+#include "gpioCallbacks.h"
-#include <fsfwconfig/devices/gpioIds.h>
+#include <devices/gpioIds.h>
-#include <linux/gpio/LinuxLibgpioIF.h>
+
-#include <linux/gpio/GpioCookie.h>
+#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
 
 

bsp_q7s/gpio/gpioCallbacks.h

@@ -1,8 +1,8 @@
 #ifndef LINUX_GPIO_GPIOCALLBACKS_H_
 #define LINUX_GPIO_GPIOCALLBACKS_H_
 
-#include <linux/gpio/gpioDefinitions.h>
+#include <fsfw_hal/common/gpio/gpioDefinitions.h>
-#include <linux/gpio/GpioIF.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
 
 
 namespace gpioCallbacks {

bsp_rpi/InitMission.cpp

@@ -3,13 +3,9 @@
 
 #include <fsfwconfig/objects/systemObjectList.h>
 #include <fsfwconfig/OBSWConfig.h>
-<<<<<<< HEAD
+#include <fsfwconfig/pollingsequence/pollingSequenceFactory.h>
-#include <fsfwconfig/pollingsequence/PollingSequenceFactory.h>
 
-=======
->>>>>>> develop
 #include <mission/utility/InitMission.h>
-
 #include <fsfw/objectmanager/ObjectManagerIF.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
@@ -17,10 +13,6 @@
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 #include <fsfw/tasks/PeriodicTaskIF.h>
 #include <fsfw/tasks/TaskFactory.h>
-<<<<<<< HEAD
-=======
-#include <fsfwconfig/pollingsequence/pollingSequenceFactory.h>
->>>>>>> develop
 
 #include <iostream>
 
@@ -124,8 +116,6 @@ void initmission::initTasks() {
     result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
     if(result != HasReturnvaluesIF::RETURN_OK) {
         initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
-<<<<<<< HEAD
-=======
     }
 
     PeriodicTaskIF* pusLowPrio = factory->createPeriodicTask(
@@ -135,24 +125,6 @@ void initmission::initTasks() {
         initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
     }
 
-#if RPI_TEST_ACS_BOARD == 1
-    FixedTimeslotTaskIF* acsTask = factory->createFixedTimeslotTask(
-            "ACS_PST", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 1.0, missedDeadlineFunc);
-    result = pst::pollingSequenceAcsTest(acsTask);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::warning << "initmission::initTasks: ACS PST initialization failed!" << std::endl;
->>>>>>> develop
-    }
-#endif /* RPI_TEST_ACS_BOARD == 1 */
-
-<<<<<<< HEAD
-    PeriodicTaskIF* pusLowPrio = factory->createPeriodicTask(
-            "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
-    result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
-    }
-
 #if RPI_TEST_ACS_BOARD == 1
     FixedTimeslotTaskIF* acsTask = factory->createFixedTimeslotTask(
             "ACS_PST", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
@@ -188,34 +160,6 @@ void initmission::initTasks() {
     udpBridgeTask->startTask();
     udpPollingTask->startTask();
 
-=======
-    PeriodicTaskIF* testTask = factory->createPeriodicTask(
-            "TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-#if OBSW_ADD_TEST_CODE == 1
-    result = testTask->addComponent(objects::TEST_TASK);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
-    }
-#endif /* OBSW_ADD_TEST_CODE == 1 */
-#if RPI_ADD_SPI_TEST == 1
-    result = testTask->addComponent(objects::SPI_TEST);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
-    }
-#endif /* RPI_ADD_SPI_TEST == 1 */
-#if RPI_ADD_GPIO_TEST == 1
-    result = testTask->addComponent(objects::LIBGPIOD_TEST);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
-    }
-#endif /* RPI_ADD_GPIO_TEST == 1 */
-
-    sif::info << "Starting tasks.." << std::endl;
-    tmTcDistributor->startTask();
-    udpBridgeTask->startTask();
-    udpPollingTask->startTask();
-
->>>>>>> develop
     pusVerification->startTask();
     pusEvents->startTask();
     pusHighPrio->startTask();

bsp_rpi/ObjectFactory.cpp

@@ -1,26 +1,4 @@
 #include "ObjectFactory.h"
-#include <bsp_rpi/gpio/GPIORPi.h>
-<<<<<<< HEAD
-
-#include <objects/systemObjectList.h>
-#include <devices/addresses.h>
-#include <devices/gpioIds.h>
-#include <OBSWConfig.h>
-#include <tmtc/apid.h>
-#include <tmtc/pusIds.h>
-
-#include <linux/boardtest/LibgpiodTest.h>
-#include <linux/boardtest/SpiTestClass.h>
-#include <linux/gpio/GpioCookie.h>
-#include <linux/gpio/LinuxLibgpioIF.h>
-
-#include <linux/spi/SpiCookie.h>
-
-#include <mission/core/GenericFactory.h>
-#include <mission/utility/TmFunnel.h>
-#include <mission/devices/MGMHandlerLIS3MDL.h>
-
-=======
 
 #include <fsfwconfig/objects/systemObjectList.h>
 #include <fsfwconfig/devices/addresses.h>
@@ -32,30 +10,28 @@
 
 #include <linux/boardtest/LibgpiodTest.h>
 #include <linux/boardtest/SpiTestClass.h>
-#include <linux/gpio/GpioCookie.h>
-#include <linux/gpio/LinuxLibgpioIF.h>
-#include <linux/spi/SpiCookie.h>
-#include <linux/spi/SpiComIF.h>
 
+#include <mission/devices/GyroL3GD20Handler.h>
 #include <mission/core/GenericFactory.h>
 #include <mission/utility/TmFunnel.h>
 #include <mission/devices/MGMHandlerLIS3MDL.h>
 #include <mission/devices/MGMHandlerRM3100.h>
 
->>>>>>> develop
 #include <fsfw/datapoollocal/LocalDataPoolManager.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
-#include <fsfw/osal/linux/TmTcUnixUdpBridge.h>
 #include <fsfw/tmtcpacket/pus/TmPacketStored.h>
-#include <fsfw/osal/linux/TcUnixUdpPollingTask.h>
 #include <fsfw/tasks/TaskFactory.h>
-<<<<<<< HEAD
-#include <linux/spi/SpiComIF.h>
-=======
-#include <mission/devices/GyroL3GD20Handler.h>
 
->>>>>>> develop
+/* UDP server includes */
+#include <fsfw/osal/common/UdpTmTcBridge.h>
+#include <fsfw/osal/common/UdpTcPollingTask.h>
+
+#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
+#include <fsfw_hal/linux/rpi/GpioRPi.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
+#include <fsfw_hal/linux/spi/SpiCookie.h>
+#include <fsfw_hal/linux/spi/SpiComIF.h>
 
 void Factory::setStaticFrameworkObjectIds() {
     PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
@@ -80,10 +56,10 @@ void ObjectFactory::produce(){
     Factory::setStaticFrameworkObjectIds();
     ObjectFactory::produceGenericObjects();
 
-    new TmTcUnixUdpBridge(objects::UDP_BRIDGE,
+    new UdpTmTcBridge(objects::UDP_BRIDGE,
             objects::CCSDS_PACKET_DISTRIBUTOR,
             objects::TM_STORE, objects::TC_STORE);
-    new TcUnixUdpPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
+    new UdpTcPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
 
     GpioIF* gpioIF = new LinuxLibgpioIF(objects::GPIO_IF);
 
@@ -125,14 +101,6 @@ void ObjectFactory::produce(){
     gpio::createRpiGpioConfig(gpioCookieAcsBoard, gpioIds::GYRO_2_L3G_CS, gpio::GYRO_2_BCM_PIN,
             "GYRO_2_L3G", gpio::Direction::OUT, 1);
     gpioIF->addGpios(gpioCookieAcsBoard);
-<<<<<<< HEAD
-
-    SpiCookie* spiCookie = new SpiCookie(addresses::MGM_0_LIS3,
-            gpioIds::MGM_0_LIS3_CS, "/dev/spidev0.0", 24, spi::SpiMode::MODE_3, 3'900'000);
-    auto mgmHandler = new MGMHandlerLIS3MDL(objects::MGM_0_LIS3_HANDLER,
-            objects::SPI_COM_IF, spiCookie);
-    mgmHandler->setStartUpImmediately();
-=======
 
     std::string spiDev = "/dev/spidev0.0";
     SpiCookie* spiCookie = new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, spiDev,
@@ -152,7 +120,6 @@ void ObjectFactory::produce(){
     auto gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_1_L3G_HANDLER, objects::SPI_COM_IF,
             spiCookie);
     gyroL3gHandler->setStartUpImmediately();
->>>>>>> develop
 
 #endif /* RPI_TEST_ACS_BOARD == 1 */
 }

bsp_rpi/gpio/CMakeLists.txt

@@ -1,5 +1,4 @@
 target_sources(${TARGET_NAME} PUBLIC
-	GPIORPi.cpp
 )
 
 

cmake/scripts/Q7S/unix_path_helper.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+export PATH=$PATH:"/opt/Xilinx/SDK/2018.2/gnu/aarch32/lin/gcc-arm-linux-gnueabi/bin"
+export CROSS_COMPILE="arm-linux-gnueabihf"
+
+export Q7S_SYSROOT="$HOME/Xilinx/cortexa9hf-neon-xiphos-linux-gnueabi"
+

cmake/scripts/Q7S/win_path_helper_xilinx_tools.sh

@@ -2,4 +2,4 @@
 export PATH=$PATH:"/c/Xilinx/SDK/2018.2/gnu/aarch32/nt/gcc-arm-linux-gnueabi/bin"
 export CROSS_COMPILE="arm-linux-gnueabihf"
 
-export Q7S_SYSROOT="/c/Xilinx/SDK/2018.2/gnu/aarch32/nt/gcc-arm-linux-gnueabi/arm-linux-gnueabihf/libc"
+export Q7S_SYSROOT="/c/Users/${USER}/Documents/EIVE/cortexa9hf-neon-xiphos-linux-gnueabi"

cmake/scripts/cmake_build_config.py

@@ -26,6 +26,9 @@ def main():
                              "Information)", default="debug")
     parser.add_argument("-l", "--builddir", type=str, help="Specify build directory.")
     parser.add_argument("-g", "--generator", type=str, help="CMake Generator")
+    parser.add_argument("-d", "--defines",
+                        help="Additional custom defines passed to CMake (supply without -D prefix!)",
+                        nargs="*", type=str)
     parser.add_argument("-t", "--target-bsp", type=str, help="Target BSP, combination of architecture and machine")
 
     args = parser.parse_args()

common/config/OBSWVersion.h

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

fsfwconfig/OBSWConfig.h

@@ -8,6 +8,8 @@
 
 #ifdef RASPBERRY_PI
 #include <rpi_config.h>
+#elif defined(XIPHOS_Q7S)
+#include <q7s_config.h>
 #endif
 #include "commonConfig.h"
 #include "OBSWVersion.h"
@@ -32,8 +34,6 @@ debugging. */
 
 /* Can be used to switch device to NORMAL mode immediately */
 #define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
-/* Can be used for low-level debugging of the SPI bus */
-#define FSFW_LINUX_SPI_WIRETAPPING                  0
 
 #ifdef __cplusplus
 

fsfwconfig/OBSWVersion.h

@@ -1,13 +0,0 @@
-#ifndef FSFWCONFIG_OBSWVERSION_H_
-#define FSFWCONFIG_OBSWVERSION_H_
-
-//! TODO: Think of a cool name for the software releases.
-const char* const SW_NAME = "eive";
-
-#define SW_VERSION 1
-#define SW_SUBVERSION 0
-#define SW_SUBSUBVERSION 0
-
-
-
-#endif /* FSFWCONFIG_OBSWVERSION_H_ */

fsfwconfig/devices/gpioIds.h

@@ -1,7 +1,7 @@
 #ifndef FSFWCONFIG_DEVICES_GPIOIDS_H_
 #define FSFWCONFIG_DEVICES_GPIOIDS_H_
 
-#include <linux/gpio/GpioIF.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
 
 namespace gpioIds {
 	enum gpioId_t {

fsfwconfig/devices/spi.h

@@ -2,7 +2,7 @@
 #define FSFWCONFIG_DEVICES_SPI_H_
 
 #include <cstdint>
-#include <linux/spi/spiDefinitions.h>
+#include <fsfw_hal/linux/spi/spiDefinitions.h>
 
 /**
  * SPI configuration will be contained here to let the device handlers remain independent

fsfwconfig/objects/systemObjectList.h

@@ -43,7 +43,7 @@ namespace objects {
 		ACU_HANDLER = 0x44000004,
 		TMP1075_HANDLER_1 = 0x44000005,
 		TMP1075_HANDLER_2 = 0x44000006,
-        MGM_0_LIS3_HANDLER = 0x4400007,
+        MGM_0_LIS3_HANDLER = 0x44000007,
 		MGM_1_RM3100_HANDLER = 0x44000008,
 		MGM_2_LIS3_HANDLER = 0x44000009,
 		MGM_3_RM3100_HANDLER = 0x44000010,
@@ -56,7 +56,7 @@ namespace objects {
 		/* Custom device handler */
 		PCDU_HANDLER = 0x44001000,
 		SOLAR_ARRAY_DEPL_HANDLER = 0x44001001,
-		SYRLINKS_HK_HANDLER = 0x44000009,
+		SYRLINKS_HK_HANDLER = 0x44001002,
 
 		/* 0x54 ('T') for thermal objects */
 		HEATER_HANDLER = 0x54000003,

fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -1,5 +1,5 @@
 #include "pollingSequenceFactory.h"
-
+#include <OBSWConfig.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
@@ -176,6 +176,52 @@ ReturnValue_t pst::gomspacePstInit(FixedTimeslotTaskIF *thisSequence){
     thisSequence->addSlot(objects::ACU_HANDLER,
             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);
+#endif
+
     if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) {
         sif::error << "Initialization of GomSpace PST failed" << std::endl;
         return HasReturnvaluesIF::RETURN_FAILED;

linux/CMakeLists.txt

@@ -1,8 +1,4 @@
-add_subdirectory(gpio)
-add_subdirectory(i2c)
 add_subdirectory(csp)
-add_subdirectory(spi)
 add_subdirectory(uart)
 add_subdirectory(utility)
 add_subdirectory(boardtest)
-

linux/archive/gpio/gpioDefinitions.h

@@ -7,6 +7,12 @@
 using gpioId_t = uint16_t;
 
 namespace gpio {
+
+enum Levels {
+    LOW = 0,
+    HIGH = 1
+};
+
 enum Direction {
     IN = 0,
     OUT = 1

linux/boardtest/LibgpiodTest.h

@@ -2,8 +2,8 @@
 #define TEST_TESTTASKS_LIBGPIODTEST_H_
 
 #include "TestTask.h"
-#include <linux/gpio/GpioIF.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
-#include <linux/gpio/GpioCookie.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
 #include <fsfw/objectmanager/SystemObject.h>
 
 /**

linux/boardtest/SpiTestClass.cpp

@@ -7,9 +7,10 @@
 #include <fsfw/tasks/TaskFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>
 
-#include <linux/gpio/gpioDefinitions.h>
+#include <fsfw_hal/linux/utility.h>
-#include <linux/gpio/GpioCookie.h>
+#include <fsfw_hal/linux/UnixFileGuard.h>
-#include <linux/utility/Utility.h>
+#include <fsfw_hal/common/gpio/gpioDefinitions.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
 
 #include <linux/spi/spidev.h>
 #include <fcntl.h>
@@ -20,7 +21,7 @@
 
 
 SpiTestClass::SpiTestClass(object_id_t objectId, GpioIF* gpioIF): TestTask(objectId),
-        gpioIF(gpioIF) {
+gpioIF(gpioIF) {
     if(gpioIF == nullptr) {
         sif::error << "SpiTestClass::SpiTestClass: Invalid GPIO ComIF!" << std::endl;
     }
@@ -35,11 +36,11 @@ ReturnValue_t SpiTestClass::performOneShotAction() {
         break;
     }
     case(TestModes::MGM_LIS3MDL): {
-        performLis3MdlTest(mgm0Lis3ChipSelect);
+        performLis3MdlTest(mgm2Lis3mdlChipSelect);
         break;
     }
     case(TestModes::MGM_RM3100): {
-        performRm3100Test(mgm1Rm3100ChipSelect);
+        performRm3100Test(mgm3Rm3100ChipSelect);
         break;
     }
     case(TestModes::GYRO_L3GD20H): {
@@ -77,12 +78,12 @@ void SpiTestClass::performRm3100Test(uint8_t mgmId) {
 #ifdef RASPBERRY_PI
     std::string deviceName = "/dev/spidev0.0";
 #else
-    std::string deviceName = "placeholder";
+    std::string deviceName = "/dev/spidev2.0";
 #endif
     int fileDescriptor = 0;
 
 
-    utility::UnixFileHelper fileHelper(deviceName, &fileDescriptor, O_RDWR,
+    UnixFileGuard fileHelper(deviceName, &fileDescriptor, O_RDWR,
             "SpiComIF::initializeInterface: ");
     if(fileHelper.getOpenResult()) {
         sif::error << "SpiTestClass::performRm3100Test: File descriptor could not be opened!"
@@ -159,13 +160,14 @@ void SpiTestClass::performLis3MdlTest(uint8_t lis3Id) {
     acsInit();
 
     /* Adapt accordingly */
-    if(lis3Id != mgm0Lis3ChipSelect and lis3Id != mgm2Lis3mdlChipSelect) {
+    if(lis3Id != mgm0Lis3mdlChipSelect and lis3Id != mgm2Lis3mdlChipSelect) {
         sif::warning << "SpiTestClass::performLis3MdlTest: Invalid MGM ID!" << std::endl;
     }
     gpioId_t currentGpioId = 0;
     uint8_t chipSelectPin = lis3Id;
     uint8_t whoAmIReg = 0b0000'1111;
-    if(chipSelectPin == mgm0Lis3ChipSelect) {
+    uint8_t whoAmIRegExpectedVal = 0b0011'1101;
+    if(chipSelectPin == mgm0Lis3mdlChipSelect) {
         currentGpioId = gpioIds::MGM_0_LIS3_CS;
     }
     else {
@@ -176,11 +178,11 @@ void SpiTestClass::performLis3MdlTest(uint8_t lis3Id) {
 #ifdef RASPBERRY_PI
     std::string deviceName = "/dev/spidev0.0";
 #else
-    std::string deviceName = "placeholder";
+    std::string deviceName = "/dev/spidev2.0";
 #endif
     int fileDescriptor = 0;
 
-    utility::UnixFileHelper fileHelper(deviceName, &fileDescriptor, O_RDWR,
+    UnixFileGuard fileHelper(deviceName, &fileDescriptor, O_RDWR,
             "SpiComIF::initializeInterface: ");
     if(fileHelper.getOpenResult()) {
         sif::error << "SpiTestClass::performLis3Mdl3100Test: File descriptor could not be opened!"
@@ -188,10 +190,15 @@ void SpiTestClass::performLis3MdlTest(uint8_t lis3Id) {
         return;
     }
     setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
+    spiTransferStruct.delay_usecs = 0;
 
     uint8_t whoAmIRegVal = readStmRegister(fileDescriptor, currentGpioId, whoAmIReg, false);
     sif::info << "SpiTestClass::performLis3MdlTest: WHO AM I register 0b" <<
             std::bitset<8>(whoAmIRegVal) << std::endl;
+    if(whoAmIRegVal != whoAmIRegExpectedVal) {
+        sif::warning << "SpiTestClass::performLis3MdlTest: WHO AM I register invalid!"
+                << std::endl;
+    }
 
 }
 
@@ -222,11 +229,11 @@ void SpiTestClass::performL3gTest(uint8_t l3gId) {
 #ifdef RASPBERRY_PI
     std::string deviceName = "/dev/spidev0.0";
 #else
-    std::string deviceName = "placeholder";
+    std::string deviceName = "/dev/spidev2.0";
 #endif
     int fileDescriptor = 0;
 
-    utility::UnixFileHelper fileHelper(deviceName, &fileDescriptor, O_RDWR,
+    UnixFileGuard fileHelper(deviceName, &fileDescriptor, O_RDWR,
             "SpiComIF::initializeInterface: ");
     if(fileHelper.getOpenResult()) {
         sif::error << "SpiTestClass::performLis3Mdl3100Test: File descriptor could not be opened!"
@@ -258,8 +265,8 @@ void SpiTestClass::performL3gTest(uint8_t l3gId) {
                 sizeof(readRegs));
         for(uint8_t idx = 0; idx < sizeof(readRegs); idx++) {
             if(readRegs[idx] != commandRegs[0]) {
-                sif::warning << "SpiTestClass::performL3gTest: Read control register" <<
+                sif::warning << "SpiTestClass::performL3gTest: Read control register " <<
-                        static_cast<int>(idx + 1) << "not equal to configured value" << std::endl;
+                        static_cast<int>(idx + 1) << " not equal to configured value" << std::endl;
             }
         }
     }
@@ -292,42 +299,68 @@ void SpiTestClass::performL3gTest(uint8_t l3gId) {
 
 void SpiTestClass::acsInit() {
     GpioCookie* gpioCookie = new GpioCookie();
+    GpiodRegular* gpio = nullptr;
+#ifdef RASPBERRY_PI
     std::string rpiGpioName = "gpiochip0";
-    {
+    gpio = new GpiodRegular(rpiGpioName, mgm0Lis3mdlChipSelect, "MGM_0_LIS3",
-        GpiodRegular gpio(rpiGpioName, mgm0Lis3ChipSelect, "MGM_0_LIS3",
+            gpio::Direction::OUT, 1);
-                gpio::Direction::OUT, 1);
+    gpioCookie->addGpio(gpioIds::MGM_0_LIS3_CS, gpio);
-        gpioCookie->addGpio(gpioIds::MGM_0_LIS3_CS, &gpio);
+
-    }
+    gpio = new GpiodRegular(rpiGpioName, mgm1Rm3100ChipSelect, "MGM_1_RM3100",
-    {
+            gpio::Direction::OUT, 1);
-        GpiodRegular gpio(rpiGpioName, mgm1Rm3100ChipSelect, "MGM_1_RM3100",
+    gpioCookie->addGpio(gpioIds::MGM_1_RM3100_CS, gpio);
-                gpio::Direction::OUT, 1);
+
-        gpioCookie->addGpio(gpioIds::MGM_1_RM3100_CS, &gpio);
+    gpio = new GpiodRegular(rpiGpioName, gyro0AdisChipSelect, "GYRO_0_ADIS",
-    }
+            gpio::Direction::OUT, 1);
-    {
+    gpioCookie->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio);
-        GpiodRegular gpio(rpiGpioName, gyro0AdisChipSelect, "GYRO_0_ADIS",
+
-                gpio::Direction::OUT, 1);
+    gpio = new GpiodRegular(rpiGpioName, gyro1L3gd20ChipSelect, "GYRO_1_L3G",
-        gpioCookie->addGpio(gpioIds::GYRO_0_ADIS_CS, &gpio);
+            gpio::Direction::OUT, 1);
-    }
+    gpioCookie->addGpio(gpioIds::GYRO_1_L3G_CS, gpio);
-    {
+
-        GpiodRegular gpio(rpiGpioName, gyro1L3gd20ChipSelect, "GYRO_1_L3G",
+    gpio = new GpiodRegular(rpiGpioName, gyro2L3gd20ChipSelect, "GYRO_2_L3G",
-                gpio::Direction::OUT, 1);
+            gpio::Direction::OUT, 1);
-        gpioCookie->addGpio(gpioIds::GYRO_1_L3G_CS, &gpio);
+    gpioCookie->addGpio(gpioIds::GYRO_2_L3G_CS, gpio);
-    }
+
-    {
+    gpio = new GpiodRegular(rpiGpioName, mgm2Lis3mdlChipSelect, "MGM_2_LIS3",
-        GpiodRegular gpio(rpiGpioName, gyro2L3gd20ChipSelect, "GYRO_2_L3G",
+            gpio::Direction::OUT, 1);
-                gpio::Direction::OUT, 1);
+    gpioCookie->addGpio(gpioIds::MGM_2_LIS3_CS, gpio);
-        gpioCookie->addGpio(gpioIds::GYRO_2_L3G_CS, &gpio);
+
-    }
+    gpio = new GpiodRegular(rpiGpioName, mgm3Rm3100ChipSelect, "MGM_3_RM3100",
-    {
+            gpio::Direction::OUT, 1);
-        GpiodRegular gpio(rpiGpioName, mgm2Lis3mdlChipSelect, "MGM_2_LIS3",
+    gpioCookie->addGpio(gpioIds::MGM_3_RM3100_CS, gpio);
-                gpio::Direction::OUT, 1);
+#elif defined(XIPHOS_Q7S)
-        gpioCookie->addGpio(gpioIds::MGM_2_LIS3_CS, &gpio);
+    std::string q7sGpioName5 = "gpiochip5";
-    }
+    std::string q7sGpioName6 = "gpiochip6";
-    {
+
-        GpiodRegular gpio(rpiGpioName, mgm3Rm3100ChipSelect, "MGM_3_RM3100",
+    gpio = new GpiodRegular(q7sGpioName5, mgm0Lis3mdlChipSelect, "MGM_0_LIS3",
-                gpio::Direction::OUT, 1);
+            gpio::Direction::OUT, gpio::HIGH);
-        gpioCookie->addGpio(gpioIds::MGM_3_RM3100_CS, &gpio);
+    gpioCookie->addGpio(gpioIds::MGM_0_LIS3_CS, gpio);
-    }
+
+    gpio = new GpiodRegular(q7sGpioName5, mgm1Rm3100ChipSelect, "MGM_1_RM3100",
+            gpio::Direction::OUT, gpio::HIGH);
+    gpioCookie->addGpio(gpioIds::MGM_1_RM3100_CS, gpio);
+
+    gpio = new GpiodRegular(q7sGpioName5, gyro0AdisChipSelect, "GYRO_0_ADIS",
+            gpio::Direction::OUT, gpio::HIGH);
+    gpioCookie->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio);
+
+    gpio = new GpiodRegular(q7sGpioName5, gyro1L3gd20ChipSelect, "GYRO_1_L3G",
+            gpio::Direction::OUT, gpio::HIGH);
+    gpioCookie->addGpio(gpioIds::GYRO_1_L3G_CS, gpio);
+
+    gpio = new GpiodRegular(q7sGpioName5, gyro2L3gd20ChipSelect, "GYRO_2_L3G",
+            gpio::Direction::OUT, gpio::HIGH);
+    gpioCookie->addGpio(gpioIds::GYRO_2_L3G_CS, gpio);
+
+    gpio = new GpiodRegular(q7sGpioName6, mgm2Lis3mdlChipSelect, "MGM_2_LIS3",
+            gpio::Direction::OUT, gpio::HIGH);
+    gpioCookie->addGpio(gpioIds::MGM_2_LIS3_CS, gpio);
+
+    gpio = new GpiodRegular(q7sGpioName5, mgm3Rm3100ChipSelect, "MGM_3_RM3100",
+            gpio::Direction::OUT, gpio::HIGH);
+    gpioCookie->addGpio(gpioIds::MGM_3_RM3100_CS, gpio);
+#endif
     if(gpioIF != nullptr) {
         gpioIF->addGpios(gpioCookie);
     }

linux/boardtest/SpiTestClass.h

@@ -1,8 +1,8 @@
 #ifndef LINUX_BOARDTEST_SPITESTCLASS_H_
 #define LINUX_BOARDTEST_SPITESTCLASS_H_
 
-#include <linux/gpio/GpioIF.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
-#include <linux/spi/SpiCookie.h>
+#include <fsfw_hal/linux/spi/SpiCookie.h>
 #include <test/testtasks/TestTask.h>
 
 #include <vector>
@@ -38,13 +38,24 @@ private:
     void acsInit();
 
     /* ACS board specific variables */
-    uint8_t mgm0Lis3ChipSelect = 0;
+#ifdef RASPBERRY_PI
+    uint8_t mgm0Lis3mdlChipSelect = 0;
     uint8_t mgm1Rm3100ChipSelect = 1;
     uint8_t gyro0AdisChipSelect = 5;
     uint8_t gyro1L3gd20ChipSelect = 6;
     uint8_t gyro2L3gd20ChipSelect = 4;
     uint8_t mgm2Lis3mdlChipSelect = 17;
     uint8_t mgm3Rm3100ChipSelect = 27;
+#elif defined(XIPHOS_Q7S)
+    uint8_t mgm0Lis3mdlChipSelect = 5;
+    uint8_t mgm1Rm3100ChipSelect = 17;
+    uint8_t gyro0AdisResetLine = 20;
+    uint8_t gyro0AdisChipSelect = 21;
+    uint8_t gyro1L3gd20ChipSelect = 10;
+    uint8_t gyro2L3gd20ChipSelect = 3;
+    uint8_t mgm2Lis3mdlChipSelect = 0;
+    uint8_t mgm3Rm3100ChipSelect = 23;
+#endif
 
     static constexpr uint8_t STM_READ_MASK = 0b1000'0000;
     static constexpr uint8_t RM3100_READ_MASK = STM_READ_MASK;

linux/i2c/CMakeLists.txt

@@ -1,8 +0,0 @@
-target_sources(${TARGET_NAME} PUBLIC
-	I2cComIF.cpp
-	I2cCookie.cpp
-)
-
-
-
-

linux/i2c/I2cComIF.cpp

@@ -1,196 +0,0 @@
-#include "I2cComIF.h"
-#include <fsfw/serviceinterface/ServiceInterface.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <linux/i2c-dev.h>
-#include <errno.h>
-#include <linux/utility/Utility.h>
-
-#include <cstring>
-
-
-I2cComIF::I2cComIF(object_id_t objectId): SystemObject(objectId){
-}
-
-I2cComIF::~I2cComIF() {}
-
-ReturnValue_t I2cComIF::initializeInterface(CookieIF* cookie) {
-
-    address_t i2cAddress;
-    std::string deviceFile;
-
-    if(cookie == nullptr) {
-        sif::error << "I2cComIF::initializeInterface: Invalid cookie!" << std::endl;
-        return NULLPOINTER;
-    }
-    I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
-    if(i2cCookie == nullptr) {
-        sif::error << "I2cComIF::initializeInterface: Invalid I2C cookie!" << std::endl;
-        return NULLPOINTER;
-    }
-
-    i2cAddress = i2cCookie->getAddress();
-
-    i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
-    if(i2cDeviceMapIter == i2cDeviceMap.end()) {
-        size_t maxReplyLen = i2cCookie->getMaxReplyLen();
-        I2cInstance_t i2cInstance = {std::vector<uint8_t>(maxReplyLen), 0};
-        auto statusPair = i2cDeviceMap.emplace(i2cAddress, i2cInstance);
-        if (not statusPair.second) {
-            sif::error << "I2cComIF::initializeInterface: Failed to insert device with address " <<
-                    i2cAddress << "to I2C device " << "map" << std::endl;
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-    sif::error << "I2cComIF::initializeInterface: Device with address " << i2cAddress <<
-            "already in use" << std::endl;
-    return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t I2cComIF::sendMessage(CookieIF *cookie,
-        const uint8_t *sendData, size_t sendLen) {
-
-    ReturnValue_t result;
-    int fd;
-    std::string deviceFile;
-
-    if(sendData == nullptr) {
-        sif::error << "I2cComIF::sendMessage: Send Data is nullptr"
-                << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    if(sendLen == 0) {
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-    I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
-    if(i2cCookie == nullptr) {
-        sif::error << "I2cComIF::sendMessage: Invalid I2C Cookie!" << std::endl;
-        return NULLPOINTER;
-    }
-
-    address_t i2cAddress = i2cCookie->getAddress();
-    i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
-    if (i2cDeviceMapIter == i2cDeviceMap.end()) {
-        sif::error << "I2cComIF::sendMessage: i2cAddress of Cookie not "
-                << "registered in i2cDeviceMap" << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    deviceFile = i2cCookie->getDeviceFile();
-    utility::UnixFileHelper fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::sendMessage");
-    if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
-        return fileHelper.getOpenResult();
-    }
-    result = openDevice(deviceFile, i2cAddress, &fd);
-    if (result != HasReturnvaluesIF::RETURN_OK){
-        return result;
-    }
-
-    if (write(fd, sendData, sendLen) != (int)sendLen) {
-        sif::error << "I2cComIF::sendMessage: Failed to send data to I2C "
-                "device with error code " << errno << ". Error description: "
-                << strerror(errno) << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t I2cComIF::getSendSuccess(CookieIF *cookie) {
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF *cookie,
-        size_t requestLen) {
-    ReturnValue_t result;
-    int fd;
-    std::string deviceFile;
-
-    if (requestLen == 0) {
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-    I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
-    if(i2cCookie == nullptr) {
-        sif::error << "I2cComIF::requestReceiveMessage: Invalid I2C Cookie!" << std::endl;
-        i2cDeviceMapIter->second.replyLen = 0;
-        return NULLPOINTER;
-    }
-
-    address_t i2cAddress = i2cCookie->getAddress();
-    i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
-    if (i2cDeviceMapIter == i2cDeviceMap.end()) {
-        sif::error << "I2cComIF::requestReceiveMessage: i2cAddress of Cookie not "
-                << "registered in i2cDeviceMap" << std::endl;
-        i2cDeviceMapIter->second.replyLen = 0;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    deviceFile = i2cCookie->getDeviceFile();
-    utility::UnixFileHelper fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::requestReceiveMessage");
-    if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
-        return fileHelper.getOpenResult();
-    }
-    result = openDevice(deviceFile, i2cAddress, &fd);
-    if (result != HasReturnvaluesIF::RETURN_OK){
-        i2cDeviceMapIter->second.replyLen = 0;
-        return result;
-    }
-
-    uint8_t* replyBuffer = i2cDeviceMapIter->second.replyBuffer.data();
-
-    if (read(fd, replyBuffer, requestLen) != static_cast<int>(requestLen)) {
-        sif::error << "I2cComIF::requestReceiveMessage: Reading from I2C "
-                << "device failed with error code " << errno <<". Description"
-                << " of error: " << strerror(errno) << std::endl;
-        i2cDeviceMapIter->second.replyLen = 0;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    i2cDeviceMapIter->second.replyLen = requestLen;
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t I2cComIF::readReceivedMessage(CookieIF *cookie,
-        uint8_t **buffer, size_t* size) {
-    I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
-    if(i2cCookie == nullptr) {
-        sif::error << "I2cComIF::readReceivedMessage: Invalid I2C Cookie!" << std::endl;
-        return NULLPOINTER;
-    }
-
-    address_t i2cAddress = i2cCookie->getAddress();
-    i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
-    if (i2cDeviceMapIter == i2cDeviceMap.end()) {
-        sif::error << "I2cComIF::readReceivedMessage: i2cAddress of Cookie not "
-                << "found in i2cDeviceMap" << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    *buffer = i2cDeviceMapIter->second.replyBuffer.data();
-    *size = i2cDeviceMapIter->second.replyLen;
-
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t I2cComIF::openDevice(std::string deviceFile,
-        address_t i2cAddress, int* fileDescriptor) {
-
-    if (ioctl(*fileDescriptor, I2C_SLAVE, i2cAddress) < 0) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "I2cComIF: Specifying target device failed with error code " << errno << "."
-                << std::endl;
-        sif::warning << "Error description " << strerror(errno) << std::endl;
-#else
-        sif::printWarning("I2cComIF: Specifying target device failed with error code %d.\n");
-        sif::printWarning("Error description: %s\n", strerror(errno));
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}

linux/i2c/I2cComIF.h

@@ -1,59 +0,0 @@
-#ifndef LINUX_I2C_I2COMIF_H_
-#define LINUX_I2C_I2COMIF_H_
-
-#include "I2cCookie.h"
-#include <fsfw/objectmanager/SystemObject.h>
-#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
-
-#include <unordered_map>
-#include <vector>
-
-/**
- * @brief 	This is the communication interface for i2c devices connected
- * 			to a system running a linux OS.
- *
- * @author 	J. Meier
- */
-class I2cComIF: public DeviceCommunicationIF, public SystemObject {
-public:
-	I2cComIF(object_id_t objectId);
-
-	virtual ~I2cComIF();
-
-	ReturnValue_t initializeInterface(CookieIF * cookie) override;
-	ReturnValue_t sendMessage(CookieIF *cookie,const uint8_t *sendData,
-			size_t sendLen) override;
-	ReturnValue_t getSendSuccess(CookieIF *cookie) override;
-	ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-	        size_t requestLen) override;
-	ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
-			size_t *size) override;
-
-private:
-
-	typedef struct I2cInstance {
-		std::vector<uint8_t> replyBuffer;
-		size_t replyLen;
-	} I2cInstance_t;
-
-	using I2cDeviceMap = std::unordered_map<address_t, I2cInstance_t>;
-	using I2cDeviceMapIter = I2cDeviceMap::iterator;
-
-	/* In this map all i2c devices will be registered with their address and
-	 * the appropriate file descriptor will be stored */
-	I2cDeviceMap i2cDeviceMap;
-	I2cDeviceMapIter i2cDeviceMapIter;
-
-	/**
-	 * @brief	This function opens an I2C device and binds the opened file
-	 * 			to a specific I2C address.
-	 * @param deviceFile	The name of the device file. E.g. i2c-0
-	 * @param i2cAddress	The address of the i2c slave device.
-	 * @param fileDescriptor	Pointer to device descriptor.
-	 * @return	RETURN_OK if successful, otherwise RETURN_FAILED.
-	 */
-	ReturnValue_t openDevice(std::string deviceFile,
-			address_t i2cAddress, int* fileDescriptor);
-};
-
-#endif /* LINUX_I2C_I2COMIF_H_ */

linux/i2c/I2cCookie.cpp

@@ -1,20 +0,0 @@
-#include "I2cCookie.h"
-
-I2cCookie::I2cCookie(address_t i2cAddress_, size_t maxReplyLen_,
-		std::string deviceFile_) :
-		i2cAddress(i2cAddress_), maxReplyLen(maxReplyLen_), deviceFile(deviceFile_) {
-}
-
-address_t I2cCookie::getAddress() const {
-	return i2cAddress;
-}
-
-size_t I2cCookie::getMaxReplyLen() const {
-	return maxReplyLen;
-}
-
-std::string I2cCookie::getDeviceFile() const {
-	return deviceFile;
-}
-
-I2cCookie::~I2cCookie() {}

linux/i2c/I2cCookie.h

@@ -1,38 +0,0 @@
-#ifndef LINUX_I2C_I2CCOOKIE_H_
-#define LINUX_I2C_I2CCOOKIE_H_
-
-#include <fsfw/devicehandlers/CookieIF.h>
-#include <string>
-
-/**
- * @brief   Cookie for the i2cDeviceComIF.
- *
- * @author 	J. Meier
- */
-class I2cCookie: public CookieIF {
-public:
-
-	/**
-	 * @brief	Constructor for the I2C cookie.
-	 * @param i2cAddress_	The i2c address of the target device.
-	 * @param maxReplyLen_	The maximum expected length of a reply from the
-	 * 						target device.
-	 * @param devicFile_    The device file specifying the i2c interface to use. E.g. "/dev/i2c-0".
-	 */
-	I2cCookie(address_t i2cAddress_, size_t maxReplyLen_,
-			std::string deviceFile_);
-
-	virtual ~I2cCookie();
-
-	address_t getAddress() const;
-	size_t getMaxReplyLen() const;
-	std::string getDeviceFile() const;
-
-private:
-
-	address_t i2cAddress = 0;
-	size_t maxReplyLen = 0;
-	std::string deviceFile;
-};
-
-#endif /* LINUX_I2C_I2CCOOKIE_H_ */

linux/spi/CMakeLists.txt

@@ -1,8 +0,0 @@
-target_sources(${TARGET_NAME} PUBLIC
-    SpiComIF.cpp
-    SpiCookie.cpp
-)
-
-
-
-

linux/spi/SpiComIF.cpp

@@ -1,321 +0,0 @@
-#include "SpiComIF.h"
-#include <OBSWConfig.h>
-
-#include <linux/utility/Utility.h>
-#include <linux/spi/SpiCookie.h>
-
-#include <fsfw/ipc/MutexFactory.h>
-#include <fsfw/ipc/MutexGuard.h>
-#include <fsfw/globalfunctions/arrayprinter.h>
-
-#include <linux/spi/spidev.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/ioctl.h>
-
-#include <cerrno>
-#include <cstring>
-
-SpiComIF::SpiComIF(object_id_t objectId, GpioIF* gpioComIF): SystemObject(objectId),
-        gpioComIF(gpioComIF) {
-    if(gpioComIF == nullptr) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "SpiComIF::SpiComIF: GPIO communication interface invalid!" << std::endl;
-#else
-        sif::printError("SpiComIF::SpiComIF: GPIO communication interface invalid!\n");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-    }
-
-    spiMutex = MutexFactory::instance()->createMutex();
-}
-
-ReturnValue_t SpiComIF::initializeInterface(CookieIF *cookie) {
-    int retval = 0;
-    SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
-    if(spiCookie == nullptr) {
-        return NULLPOINTER;
-    }
-
-    address_t spiAddress = spiCookie->getSpiAddress();
-
-    auto iter = spiDeviceMap.find(spiAddress);
-    if(iter == spiDeviceMap.end()) {
-        size_t bufferSize = spiCookie->getMaxBufferSize();
-        SpiInstance spiInstance = {std::vector<uint8_t>(bufferSize)};
-        auto statusPair = spiDeviceMap.emplace(spiAddress, spiInstance);
-        if (not statusPair.second) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "SpiComIF::initializeInterface: Failed to insert device with address " <<
-                    spiAddress << "to SPI device map" << std::endl;
-#else
-            sif::printError("SpiComIF::initializeInterface: Failed to insert device with address "
-                    "%lu to SPI device map\n", static_cast<unsigned long>(spiAddress));
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        /* Now we emplaced the read buffer in the map, we still need to assign that location
-        to the SPI driver transfer struct */
-        spiCookie->assignReadBuffer(statusPair.first->second.replyBuffer.data());
-    }
-    else {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "SpiComIF::initializeInterface: SPI address already exists!" << std::endl;
-#else
-        sif::printError("SpiComIF::initializeInterface: SPI address already exists!\n");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    /* Pull CS high in any case to be sure that device is inactive */
-    gpioId_t gpioId = spiCookie->getChipSelectPin();
-    if(gpioId != gpio::NO_GPIO) {
-        gpioComIF->pullHigh(gpioId);
-    }
-
-    size_t spiSpeed = 0;
-    spi::SpiModes spiMode = spi::SpiModes::MODE_0;
-
-    SpiCookie::UncommonParameters params;
-    spiCookie->getSpiParameters(spiMode, spiSpeed, &params);
-
-    int fileDescriptor = 0;
-    utility::UnixFileHelper fileHelper(spiCookie->getSpiDevice(), &fileDescriptor, O_RDWR,
-            "SpiComIF::initializeInterface: ");
-    if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
-        return fileHelper.getOpenResult();
-    }
-
-    /* These flags are rather uncommon */
-    if(params.threeWireSpi or params.noCs or params.csHigh) {
-        uint32_t currentMode = 0;
-        retval = ioctl(fileDescriptor, SPI_IOC_RD_MODE32, &currentMode);
-        if(retval != 0) {
-            utility::handleIoctlError("SpiComIF::initialiezInterface: Could not read full mode!");
-        }
-
-        if(params.threeWireSpi) {
-            currentMode |= SPI_3WIRE;
-        }
-        if(params.noCs) {
-            /* Some drivers like the Raspberry Pi ignore this flag in any case */
-            currentMode |= SPI_NO_CS;
-        }
-        if(params.csHigh) {
-            currentMode |= SPI_CS_HIGH;
-        }
-        /* Write adapted mode */
-        retval = ioctl(fileDescriptor, SPI_IOC_WR_MODE32, &currentMode);
-        if(retval != 0) {
-            utility::handleIoctlError("SpiComIF::initialiezInterface: Could not write full mode!");
-        }
-    }
-    if(params.lsbFirst) {
-        retval = ioctl(fileDescriptor, SPI_IOC_WR_LSB_FIRST, &params.lsbFirst);
-        if(retval != 0) {
-            utility::handleIoctlError("SpiComIF::initializeInterface: Setting LSB first failed");
-        }
-    }
-    if(params.bitsPerWord != 8) {
-        retval = ioctl(fileDescriptor, SPI_IOC_WR_BITS_PER_WORD, &params.bitsPerWord);
-        if(retval != 0) {
-            utility::handleIoctlError("SpiComIF::initializeInterface: "
-                    "Could not write bits per word!");
-        }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t SpiComIF::sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) {
-    SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    int retval = 0;
-
-    if(spiCookie == nullptr) {
-        return NULLPOINTER;
-    }
-
-    if(sendLen > spiCookie->getMaxBufferSize()) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "SpiComIF::sendMessage: Too much data sent, send length" << sendLen <<
-                "larger than maximum buffer length" << spiCookie->getMaxBufferSize() << std::endl;
-#else
-        sif::printWarning("SpiComIF::sendMessage: Too much data sent, send length %lu larger "
-                "than maximum buffer length %lu!\n", static_cast<unsigned long>(sendLen),
-                static_cast<unsigned long>(spiCookie->getMaxBufferSize()));
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-        return DeviceCommunicationIF::TOO_MUCH_DATA;
-    }
-
-
-    /* Prepare transfer */
-    int fileDescriptor = 0;
-    std::string device = spiCookie->getSpiDevice();
-    utility::UnixFileHelper fileHelper(device, &fileDescriptor, O_RDWR,
-            "SpiComIF::sendMessage: ");
-    if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
-        return OPENING_FILE_FAILED;
-    }
-    spi::SpiModes spiMode = spi::SpiModes::MODE_0;
-    uint32_t spiSpeed = 0;
-    spiCookie->getSpiParameters(spiMode, spiSpeed, nullptr);
-    setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
-    spiCookie->assignWriteBuffer(sendData);
-    spiCookie->assignTransferSize(sendLen);
-
-    bool fullDuplex = spiCookie->isFullDuplex();
-    gpioId_t gpioId = spiCookie->getChipSelectPin();
-
-    /* GPIO access is mutex protected */
-    MutexGuard(spiMutex, timeoutType, timeoutMs);
-
-    /* Pull SPI CS low. For now, no support for active high given  */
-    if(gpioId != gpio::NO_GPIO) {
-        gpioComIF->pullLow(gpioId);
-    }
-
-    /* Execute transfer */
-    if(fullDuplex) {
-        /* Initiate a full duplex SPI transfer. */
-        retval = ioctl(fileDescriptor, SPI_IOC_MESSAGE(1), spiCookie->getTransferStructHandle());
-        if(retval < 0) {
-            utility::handleIoctlError("SpiComIF::sendMessage: ioctl error.");
-            result = FULL_DUPLEX_TRANSFER_FAILED;
-        }
-#if FSFW_LINUX_SPI_WIRETAPPING == 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "Sent SPI data: " << std::endl;
-        size_t dataLen = spiCookie->getTransferStructHandle()->len;
-        uint8_t* dataPtr = reinterpret_cast<uint8_t*>(spiCookie->getTransferStructHandle()->tx_buf);
-        arrayprinter::print(dataPtr, dataLen, OutputType::HEX, false);
-        sif::info << "Received SPI data: " << std::endl;
-        dataPtr = reinterpret_cast<uint8_t*>(spiCookie->getTransferStructHandle()->rx_buf);
-        arrayprinter::print(dataPtr, dataLen, OutputType::HEX, false);
-#else
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_LINUX_SPI_WIRETAPPING == 1 */
-    }
-    else {
-        /* We write with a blocking half-duplex transfer here */
-        if (write(fileDescriptor, sendData, sendLen) != static_cast<ssize_t>(sendLen)) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::warning << "SpiComIF::sendMessage: Half-Duplex write operation failed!" <<
-                    std::endl;
-#else
-            sif::printWarning("SpiComIF::sendMessage: Half-Duplex write operation failed!\n");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-            result = HALF_DUPLEX_TRANSFER_FAILED;
-        }
-    }
-
-    if(gpioId != gpio::NO_GPIO) {
-        gpioComIF->pullHigh(gpioId);
-    }
-    return result;
-}
-
-ReturnValue_t SpiComIF::getSendSuccess(CookieIF *cookie) {
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t SpiComIF::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
-    if(spiCookie == nullptr) {
-        return NULLPOINTER;
-    }
-
-    bool fullDuplex = spiCookie->isFullDuplex();
-    if(fullDuplex) {
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-    std::string device = spiCookie->getSpiDevice();
-    int fileDescriptor = 0;
-    utility::UnixFileHelper fileHelper(device, &fileDescriptor, O_RDWR,
-            "SpiComIF::requestReceiveMessage: ");
-    if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
-        return OPENING_FILE_FAILED;
-    }
-
-    uint8_t* rxBuf = nullptr;
-    size_t readSize = spiCookie->getCurrentTransferSize();
-    result = getReadBuffer(spiCookie->getSpiAddress(), &rxBuf);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-
-    gpioId_t gpioId = spiCookie->getChipSelectPin();
-    MutexGuard(spiMutex, timeoutType, timeoutMs);
-    if(gpioId != gpio::NO_GPIO) {
-        gpioComIF->pullLow(gpioId);
-    }
-
-    if(read(fileDescriptor, rxBuf, readSize) != static_cast<ssize_t>(readSize)) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "SpiComIF::sendMessage: Half-Duplex read operation failed!" << std::endl;
-#else
-        sif::printWarning("SpiComIF::sendMessage: Half-Duplex read operation failed!\n");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-        result = HALF_DUPLEX_TRANSFER_FAILED;
-    }
-
-    if(gpioId != gpio::NO_GPIO) {
-        gpioComIF->pullHigh(gpioId);
-    }
-
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t SpiComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
-    SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
-    if(spiCookie == nullptr) {
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    uint8_t* rxBuf = nullptr;
-    ReturnValue_t result = getReadBuffer(spiCookie->getSpiAddress(), &rxBuf);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-
-    *buffer = rxBuf;
-    *size = spiCookie->getCurrentTransferSize();
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t SpiComIF::getReadBuffer(address_t spiAddress, uint8_t** buffer) {
-    if(buffer == nullptr) {
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    auto iter = spiDeviceMap.find(spiAddress);
-    if(iter == spiDeviceMap.end()) {
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    *buffer = iter->second.replyBuffer.data();
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void SpiComIF::setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed) {
-    int retval = ioctl(spiFd, SPI_IOC_WR_MODE, reinterpret_cast<uint8_t*>(&mode));
-    if(retval != 0) {
-        utility::handleIoctlError("SpiTestClass::performRm3100Test: Setting SPI mode failed!");
-    }
-
-    retval = ioctl(spiFd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
-    if(retval != 0) {
-        utility::handleIoctlError("SpiTestClass::performRm3100Test: Setting SPI speed failed!");
-    }
-}

linux/spi/SpiComIF.h

@@ -1,63 +0,0 @@
-#ifndef LINUX_SPI_SPICOMIF_H_
-#define LINUX_SPI_SPICOMIF_H_
-
-#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
-#include <fsfw/objectmanager/SystemObject.h>
-#include <linux/gpio/GpioIF.h>
-#include <linux/spi/spiDefinitions.h>
-#include <returnvalues/classIds.h>
-
-#include <vector>
-#include <unordered_map>
-
-/**
- * @brief   Encapsulates access to linux SPI driver for FSFW objects
- * @details
- * Right now, only full-duplex SPI is supported.
- * @author  R. Mueller
- */
-class SpiComIF: public DeviceCommunicationIF, public SystemObject {
-public:
-    static constexpr uint8_t spiRetvalId = CLASS_ID::LINUX_SPI_COM_IF;
-    static constexpr ReturnValue_t OPENING_FILE_FAILED =
-            HasReturnvaluesIF::makeReturnCode(spiRetvalId, 0);
-    /* Full duplex (ioctl) transfer failure */
-    static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED =
-            HasReturnvaluesIF::makeReturnCode(spiRetvalId, 1);
-    /* Half duplex (read/write) transfer failure */
-    static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
-            HasReturnvaluesIF::makeReturnCode(spiRetvalId, 2);
-
-    SpiComIF(object_id_t objectId, GpioIF* gpioComIF);
-
-    ReturnValue_t initializeInterface(CookieIF * cookie) override;
-    ReturnValue_t sendMessage(CookieIF *cookie,const uint8_t *sendData,
-            size_t sendLen) override;
-    ReturnValue_t getSendSuccess(CookieIF *cookie) override;
-    ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-            size_t requestLen) override;
-    ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
-            size_t *size) override;
-private:
-
-    struct SpiInstance {
-        std::vector<uint8_t> replyBuffer;
-    };
-
-    GpioIF* gpioComIF = nullptr;
-
-    MutexIF* spiMutex = nullptr;
-    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-    uint32_t timeoutMs = 20;
-
-    using SpiDeviceMap = std::unordered_map<address_t, SpiInstance>;
-    using SpiDeviceMapIter = SpiDeviceMap::iterator;
-
-    SpiDeviceMap spiDeviceMap;
-
-
-    ReturnValue_t getReadBuffer(address_t spiAddress, uint8_t** buffer);
-    void setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed);
-};
-
-#endif /* LINUX_SPI_SPICOMIF_H_ */

linux/spi/SpiCookie.cpp

@@ -1,107 +0,0 @@
-#include "SpiCookie.h"
-
-SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
-        const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed): spiAddress(spiAddress),
-        chipSelectPin(chipSelect), spiDevice(spiDev), maxSize(maxSize), spiMode(spiMode),
-        spiSpeed(spiSpeed) {
-}
-
-SpiCookie::SpiCookie(address_t spiAddress, std::string spiDev, const size_t maxSize,
-        spi::SpiModes spiMode, uint32_t spiSpeed):
-        SpiCookie(spiAddress, gpio::NO_GPIO, spiDev, maxSize, spiMode, spiSpeed) {
-}
-
-void SpiCookie::getSpiParameters(spi::SpiModes& spiMode, uint32_t& spiSpeed,
-        UncommonParameters* parameters) const {
-    spiMode = this->spiMode;
-    spiSpeed = this->spiSpeed;
-
-    if(parameters != nullptr) {
-        parameters->threeWireSpi = uncommonParameters.threeWireSpi;
-        parameters->lsbFirst = uncommonParameters.lsbFirst;
-        parameters->noCs = uncommonParameters.noCs;
-        parameters->bitsPerWord = uncommonParameters.bitsPerWord;
-        parameters->csHigh = uncommonParameters.csHigh;
-    }
-}
-
-gpioId_t SpiCookie::getChipSelectPin() const {
-    return chipSelectPin;
-}
-
-size_t SpiCookie::getMaxBufferSize() const {
-    return maxSize;
-}
-
-address_t SpiCookie::getSpiAddress() const {
-    return spiAddress;
-}
-
-std::string SpiCookie::getSpiDevice() const {
-    return spiDevice;
-}
-
-void SpiCookie::setThreeWireSpi(bool enable) {
-    uncommonParameters.threeWireSpi = enable;
-}
-
-void SpiCookie::setLsbFirst(bool enable) {
-    uncommonParameters.lsbFirst = enable;
-}
-
-void SpiCookie::setNoCs(bool enable) {
-    uncommonParameters.noCs = enable;
-}
-
-void SpiCookie::setBitsPerWord(uint8_t bitsPerWord) {
-    uncommonParameters.bitsPerWord = bitsPerWord;
-}
-
-void SpiCookie::setCsHigh(bool enable) {
-    uncommonParameters.csHigh = enable;
-}
-
-void SpiCookie::activateCsDeselect(bool deselectCs, uint16_t delayUsecs) {
-    spiTransferStruct.cs_change = deselectCs;
-    spiTransferStruct.delay_usecs = delayUsecs;
-}
-
-void SpiCookie::assignReadBuffer(uint8_t* rx) {
-    if(rx != nullptr) {
-        spiTransferStruct.rx_buf = reinterpret_cast<__u64>(rx);
-    }
-}
-
-void SpiCookie::assignWriteBuffer(const uint8_t* tx) {
-    if(tx != nullptr) {
-        spiTransferStruct.tx_buf = reinterpret_cast<__u64>(tx);
-    }
-}
-
-spi_ioc_transfer* SpiCookie::getTransferStructHandle() {
-    return &spiTransferStruct;
-}
-
-void SpiCookie::setFullOrHalfDuplex(bool halfDuplex) {
-    this->halfDuplex = halfDuplex;
-}
-
-bool SpiCookie::isFullDuplex() const {
-    return not this->halfDuplex;
-}
-
-void SpiCookie::assignTransferSize(size_t transferSize) {
-    spiTransferStruct.len = transferSize;
-}
-
-size_t SpiCookie::getCurrentTransferSize() const {
-    return spiTransferStruct.len;
-}
-
-void SpiCookie::setSpiSpeed(uint32_t newSpeed) {
-    this->spiSpeed = newSpeed;
-}
-
-void SpiCookie::setSpiMode(spi::SpiModes newMode) {
-    this->spiMode = newMode;
-}

linux/spi/SpiCookie.h

@@ -1,119 +0,0 @@
-#ifndef LINUX_SPI_SPICOOKIE_H_
-#define LINUX_SPI_SPICOOKIE_H_
-
-#include "spiDefinitions.h"
-#include <fsfw/devicehandlers/CookieIF.h>
-#include <linux/gpio/gpioDefinitions.h>
-#include <linux/spi/spidev.h>
-
-class SpiCookie: public CookieIF {
-public:
-
-    /**
-     * Each SPI device will have a corresponding cookie. The cookie is used by the communication
-     * interface and contains device specific information like the largest expected size to be
-     * sent and received and the GPIO pin used to toggle the SPI slave select pin.
-     * @param spiAddress
-     * @param chipSelect    Chip select. gpio::NO_GPIO can be used for hardware slave selects.
-     * @param spiDev
-     * @param maxSize
-     */
-    SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
-            const size_t maxReplySize, spi::SpiModes spiMode, uint32_t spiSpeed);
-
-    /**
-     * Like constructor above, but without a dedicated GPIO CS. Can be used for hardware
-     * slave select or if CS logic is performed with decoders.
-     */
-    SpiCookie(address_t spiAddress, std::string spiDev, const size_t maxReplySize,
-            spi::SpiModes spiMode, uint32_t spiSpeed);
-
-    address_t getSpiAddress() const;
-    std::string getSpiDevice() const;
-    gpioId_t getChipSelectPin() const;
-    size_t getMaxBufferSize() const;
-
-    /** Enables changing SPI speed at run-time */
-    void setSpiSpeed(uint32_t newSpeed);
-    /** Enables changing the SPI mode at run-time */
-    void setSpiMode(spi::SpiModes newMode);
-
-    /**
-     * True if SPI transfers should be performed in full duplex mode
-     * @return
-     */
-    bool isFullDuplex() const;
-
-    /**
-     * Set transfer type to full duplex or half duplex. Full duplex is the default setting,
-     * ressembling common SPI hardware implementation with shift registers, where read and writes
-     * happen simultaneosly.
-     * @param fullDuplex
-     */
-    void setFullOrHalfDuplex(bool halfDuplex);
-
-    /**
-     * This needs to be called to specify where the SPI driver writes to or reads from.
-     * @param readLocation
-     * @param writeLocation
-     */
-    void assignReadBuffer(uint8_t* rx);
-    void assignWriteBuffer(const uint8_t* tx);
-    /**
-     * Assign size for the next transfer.
-     * @param transferSize
-     */
-    void assignTransferSize(size_t transferSize);
-    size_t getCurrentTransferSize() const;
-
-    struct UncommonParameters {
-        uint8_t bitsPerWord = 8;
-        bool noCs = false;
-        bool csHigh = false;
-        bool threeWireSpi = false;
-        /* MSB first is more common */
-        bool lsbFirst = false;
-    };
-
-    /**
-     * Can be used to explicitely disable hardware chip select.
-     * Some drivers like the Raspberry Pi Linux driver will not use hardware chip select by default
-     * (see https://www.raspberrypi.org/documentation/hardware/raspberrypi/spi/README.md)
-     * @param enable
-     */
-    void setNoCs(bool enable);
-    void setThreeWireSpi(bool enable);
-    void setLsbFirst(bool enable);
-    void setCsHigh(bool enable);
-    void setBitsPerWord(uint8_t bitsPerWord);
-
-    void getSpiParameters(spi::SpiModes& spiMode, uint32_t& spiSpeed,
-            UncommonParameters* parameters = nullptr) const;
-
-    /**
-     * See spidev.h cs_change and delay_usecs
-     * @param deselectCs
-     * @param delayUsecs
-     */
-    void activateCsDeselect(bool deselectCs, uint16_t delayUsecs);
-
-    spi_ioc_transfer* getTransferStructHandle();
-private:
-    size_t currentTransferSize = 0;
-
-    address_t spiAddress;
-    gpioId_t chipSelectPin;
-    std::string spiDevice;
-
-    const size_t maxSize;
-    spi::SpiModes spiMode;
-    uint32_t spiSpeed;
-    bool halfDuplex = false;
-
-    struct spi_ioc_transfer spiTransferStruct = {};
-    UncommonParameters uncommonParameters;
-};
-
-
-
-#endif /* LINUX_SPI_SPICOOKIE_H_ */

linux/spi/spiDefinitions.h

@@ -1,17 +0,0 @@
-#ifndef LINUX_SPI_SPIDEFINITONS_H_
-#define LINUX_SPI_SPIDEFINITONS_H_
-
-#include <cstdint>
-
-namespace spi {
-
-enum SpiModes: uint8_t {
-    MODE_0,
-    MODE_1,
-    MODE_2,
-    MODE_3
-};
-
-}
-
-#endif /* LINUX_SPI_SPIDEFINITONS_H_ */

linux/utility/CMakeLists.txt

@@ -1,5 +1,4 @@
 target_sources(${TARGET_NAME} PUBLIC
-    Utility.cpp
 )
 
 

linux/utility/Utility.cpp

@@ -1,52 +0,0 @@
-#include "Utility.h"
-
-void utility::handleIoctlError(const char* const customPrintout) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    if(customPrintout != nullptr) {
-        sif::warning << customPrintout << std::endl;
-    }
-    sif::warning << "handleIoctlError: Error code " << errno << ", "<< strerror(errno) <<
-            std::endl;
-#else
-    if(customPrintout != nullptr) {
-        sif::printWarning("%s\n", customPrintout);
-    }
-    sif::printWarning("handleIoctlError: Error code %d, %s\n", errno, strerror(errno));
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-
-}
-
-utility::UnixFileHelper::UnixFileHelper(std::string device, int* fileDescriptor, int flags,
-        std::string diagnosticPrefix):
-        fileDescriptor(fileDescriptor) {
-    if(fileDescriptor == nullptr) {
-        return;
-    }
-    *fileDescriptor = open(device.c_str(), flags);
-    if (*fileDescriptor < 0) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << diagnosticPrefix <<"Opening device failed with error code " << errno <<
-                "." << std::endl;
-        sif::warning << "Error description: " << strerror(errno) << std::endl;
-#else
-        sif::printError("%sOpening device failed with error code %d.\n", diagnosticPrefix);
-        sif::printWarning("Error description: %s\n", strerror(errno));
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-        openStatus = OPEN_FILE_FAILED;
-    }
-}
-
-utility::UnixFileHelper::~UnixFileHelper() {
-    if(fileDescriptor != nullptr) {
-        close(*fileDescriptor);
-    }
-}
-
-ReturnValue_t utility::UnixFileHelper::getOpenResult() const {
-    return openStatus;
-}
-

linux/utility/Utility.h

@@ -1,36 +0,0 @@
-#ifndef LINUX_UTILITY_UTILITY_H_
-#define LINUX_UTILITY_UTILITY_H_
-
-#include <cerrno>
-#include <cstring>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-
-#include <fcntl.h>
-#include <unistd.h>
-
-namespace utility {
-
-void handleIoctlError(const char* const customPrintout);
-
-class UnixFileHelper {
-public:
-    static constexpr int READ_WRITE_FLAG = O_RDWR;
-    static constexpr int READ_ONLY_FLAG = O_RDONLY;
-    static constexpr int NON_BLOCKING_IO_FLAG = O_NONBLOCK;
-
-    static constexpr ReturnValue_t OPEN_FILE_FAILED = 1;
-
-    UnixFileHelper(std::string device, int* fileDescriptor, int flags,
-            std::string diagnosticPrefix = "");
-
-    virtual~ UnixFileHelper();
-
-    ReturnValue_t getOpenResult() const;
-private:
-    int* fileDescriptor = nullptr;
-    ReturnValue_t openStatus = HasReturnvaluesIF::RETURN_OK;
-};
-
-}
-
-#endif /* LINUX_UTILITY_UTILITY_H_ */

misc/eclipse/.project

@@ -7,7 +7,7 @@
 	<buildSpec>
 		<buildCommand>
 			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
-			<triggers>clean,full,incremental,</triggers>
+			<triggers>full,incremental,</triggers>
 			<arguments>
 			</arguments>
 		</buildCommand>

mission/devices/MGMHandlerLIS3MDL.cpp

@@ -33,8 +33,8 @@ void MGMHandlerLIS3MDL::doStartUp() {
         /* Will be set by checking device ID (WHO AM I register) */
         if(commandExecuted) {
             commandExecuted = false;
+            internalState = InternalState::STATE_SETUP;
         }
-        internalState = InternalState::STATE_SETUP;
         break;
     }
     case(InternalState::STATE_SETUP): {
@@ -463,7 +463,7 @@ void MGMHandlerLIS3MDL::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
 }
 
 uint32_t MGMHandlerLIS3MDL::getTransitionDelayMs(Mode_t from, Mode_t to) {
-    return 10000;
+    return 20000;
 }
 
 void MGMHandlerLIS3MDL::modeChanged(void) {

test/testtasks/TestTask.cpp

@@ -66,6 +66,14 @@ gps_rx_data[] = ""
         "$GPRMC,183731,A,3907.482,N,12102.436,W,000.0,360.0,080301,015.5,E*67\r\n"
         "$GPRMB,A,,,,,,,,,,,,V*71\r\n";
 
+const char hyperion_gps_data[] = ""
+        "$GNGGA,173225.998892,4908.5596,N,00906.2765,E,1,05,2.1,215.0,M,48.2,M,,0000*74\r\n"
+        "$GNGLL,4908.5596,N,00906.2765,E,173225.998892,A,A*7F\r\n"
+        "$GPGSA,A,3,18,16,26,31,20,,,,,,,,3.2,2.1,2.4*3C\r\n"
+        "$GNRMC,173225.998892,A,4908.5596,N,00906.2765,E,000.0,040.7,270221,,,A*4F\r\n"
+        "$GNVTG,040.7,T,,M,000.0,N,000.0,K,A*10\r\n"
+        "$GNZDA,173225.998892,27,02,2021,00,00*75\r\n";
+
 ReturnValue_t TestTask::performOneShotAction() {
 #if OBSW_ADD_TEST_CODE == 1
     //performLwgpsTest();
@@ -93,18 +101,18 @@ ReturnValue_t TestTask::performActionB() {
 
 void TestTask::performLwgpsTest() {
     /* Everything here will only be performed once. */
-    etl::vector<uint8_t, 30> testVec;
+    sif::info << "Processing sample GPS output.." << std::endl;
 
     lwgps_t gpsStruct;
     sif::info << "Size of GPS struct: " << sizeof(gpsStruct) << std::endl;
     lwgps_init(&gpsStruct);
 
     /* Process all input data */
-    lwgps_process(&gpsStruct, gps_rx_data, strlen(gps_rx_data));
+    lwgps_process(&gpsStruct, hyperion_gps_data, strlen(hyperion_gps_data));
 
     /* Print messages */
-    printf("Valid status: %d\r\n", gpsStruct.is_valid);
+    printf("Valid status: %d\n", gpsStruct.is_valid);
-    printf("Latitude: %f degrees\r\n", gpsStruct.latitude);
+    printf("Latitude: %f degrees\n", gpsStruct.latitude);
-    printf("Longitude: %f degrees\r\n", gpsStruct.longitude);
+    printf("Longitude: %f degrees\n", gpsStruct.longitude);
-    printf("Altitude: %f meters\r\n", gpsStruct.altitude);
+    printf("Altitude: %f meters\n", gpsStruct.altitude);
 }