Merge branch 'development' into mueller/gpio-update

hal/src/fsfw_hal/linux/spi/SpiComIF.cpp

@@ -15,11 +15,6 @@
 #include <cerrno>
 #include <cstring>
 
-/* Can be used for low-level debugging of the SPI bus */
-#ifndef FSFW_HAL_LINUX_SPI_WIRETAPPING
-#define FSFW_HAL_LINUX_SPI_WIRETAPPING                  0
-#endif
-
 SpiComIF::SpiComIF(object_id_t objectId, GpioIF* gpioComIF):
         SystemObject(objectId), gpioComIF(gpioComIF) {
     if(gpioComIF == nullptr) {
@@ -193,7 +188,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie *spiCookie, const
     spiCookie->getSpiParameters(spiMode, spiSpeed, nullptr);
     setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
     spiCookie->assignWriteBuffer(sendData);
-    spiCookie->assignTransferSize(sendLen);
+    spiCookie->setTransferSize(sendLen);
 
     bool fullDuplex = spiCookie->isFullDuplex();
     gpioId_t gpioId = spiCookie->getChipSelectPin();
@@ -335,6 +330,7 @@ ReturnValue_t SpiComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
 
     *buffer = rxBuf;
     *size = spiCookie->getCurrentTransferSize();
+    spiCookie->setTransferSize(0);
     return HasReturnvaluesIF::RETURN_OK;
 }
 

hal/src/fsfw_hal/linux/spi/SpiComIF.h

@@ -1,6 +1,7 @@
 #ifndef LINUX_SPI_SPICOMIF_H_
 #define LINUX_SPI_SPICOMIF_H_
 
+#include "fsfw/FSFW.h"
 #include "spiDefinitions.h"
 #include "returnvalues/classIds.h"
 #include "fsfw_hal/common/gpio/GpioIF.h"

hal/src/fsfw_hal/linux/spi/SpiCookie.cpp

@@ -121,7 +121,7 @@ bool SpiCookie::isFullDuplex() const {
     return not this->halfDuplex;
 }
 
-void SpiCookie::assignTransferSize(size_t transferSize) {
+void SpiCookie::setTransferSize(size_t transferSize) {
     spiTransferStruct.len = transferSize;
 }
 

hal/src/fsfw_hal/linux/spi/SpiCookie.h

@@ -103,10 +103,10 @@ public:
     void assignReadBuffer(uint8_t* rx);
     void assignWriteBuffer(const uint8_t* tx);
     /**
-     * Assign size for the next transfer.
+     * Set size for the next transfer. Set to 0 for no transfer
      * @param transferSize
      */
-    void assignTransferSize(size_t transferSize);
+    void setTransferSize(size_t transferSize);
     size_t getCurrentTransferSize() const;
 
     struct UncommonParameters {
@@ -158,8 +158,6 @@ private:
             std::string spiDev, const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
             spi::send_callback_function_t callback, void* args);
 
-    size_t currentTransferSize = 0;
-
     address_t spiAddress;
     gpioId_t chipSelectPin;
     std::string spiDevice;

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -461,7 +461,7 @@ size_t DeviceHandlerBase::getNextReplyLength(DeviceCommandId_t commandId){
         return iter->second.replyLen;
     }else{
         return 0;
-   }
+    }
 }
 
 ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
@@ -612,15 +612,15 @@ void DeviceHandlerBase::replyToReply(const DeviceCommandId_t command, DeviceRepl
     }
     DeviceCommandInfo* info = &replyInfo.command->second;
     if (info == nullptr){
-    	printWarningOrError(sif::OutputTypes::OUT_ERROR,
-    	                        "replyToReply", HasReturnvaluesIF::RETURN_FAILED,
-    	                        "Command pointer not found");
-    	return;
+        printWarningOrError(sif::OutputTypes::OUT_ERROR,
+                "replyToReply", HasReturnvaluesIF::RETURN_FAILED,
+                "Command pointer not found");
+        return;
     }
 
     if (info->expectedReplies > 0){
-    	// Check before to avoid underflow
-    	info->expectedReplies--;
+        // Check before to avoid underflow
+        info->expectedReplies--;
     }
     // Check if more replies are expected. If so, do nothing.
     if (info->expectedReplies == 0) {
@@ -1355,10 +1355,20 @@ void DeviceHandlerBase::buildInternalCommand(void) {
         DeviceCommandMap::iterator iter = deviceCommandMap.find(
                 deviceCommandId);
         if (iter == deviceCommandMap.end()) {
+#if FSFW_VERBOSE_LEVEL >= 1
+            char output[36];
+            sprintf(output, "Command 0x%08x unknown",
+                    static_cast<unsigned int>(deviceCommandId));
+            // so we can track misconfigurations
+            printWarningOrError(sif::OutputTypes::OUT_WARNING,
+                    "buildInternalCommand",
+                    COMMAND_NOT_SUPPORTED,
+                    output);
+#endif
             result = COMMAND_NOT_SUPPORTED;
         }
         else if (iter->second.isExecuting) {
-#if FSFW_DISABLE_PRINTOUT == 0
+#if FSFW_VERBOSE_LEVEL >= 1
             char output[36];
             sprintf(output, "Command 0x%08x is executing",
                     static_cast<unsigned int>(deviceCommandId));
@@ -1569,7 +1579,7 @@ LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
     return &poolManager;
 }
 
-MessageQueueId_t DeviceHandlerBase::getCommanderId(DeviceCommandId_t replyId) const {
+MessageQueueId_t DeviceHandlerBase::getCommanderQueueId(DeviceCommandId_t replyId) const {
     auto commandIter = deviceCommandMap.find(replyId);
     if(commandIter == deviceCommandMap.end()) {
         return MessageQueueIF::NO_QUEUE;

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -6,22 +6,22 @@
 #include "DeviceHandlerFailureIsolation.h"
 #include "DeviceHandlerThermalSet.h"
 
-#include "../serviceinterface/ServiceInterface.h"
-#include "../serviceinterface/serviceInterfaceDefintions.h"
-#include "../objectmanager/SystemObject.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../action/HasActionsIF.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../modes/HasModesIF.h"
-#include "../power/PowerSwitchIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../tasks/PeriodicTaskIF.h"
-#include "../action/ActionHelper.h"
-#include "../health/HealthHelper.h"
-#include "../parameters/ParameterHelper.h"
-#include "../datapoollocal/HasLocalDataPoolIF.h"
-#include "../datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/action/HasActionsIF.h"
+#include "fsfw/datapool/PoolVariableIF.h"
+#include "fsfw/modes/HasModesIF.h"
+#include "fsfw/power/PowerSwitchIF.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/tasks/PeriodicTaskIF.h"
+#include "fsfw/action/ActionHelper.h"
+#include "fsfw/health/HealthHelper.h"
+#include "fsfw/parameters/ParameterHelper.h"
+#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
+#include "fsfw/datapoollocal/LocalDataPoolManager.h"
 
 #include <map>
 
@@ -399,7 +399,7 @@ protected:
      */
     virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
             const uint8_t *packet) = 0;
-    MessageQueueId_t getCommanderId(DeviceCommandId_t replyId) const;
+    MessageQueueId_t getCommanderQueueId(DeviceCommandId_t replyId) const;
     /**
      * Helper function to get pending command. This is useful for devices
      * like SPI sensors to identify the last sent command.

tests/src/fsfw_tests/internal/InternalUnitTester.cpp

@@ -16,15 +16,18 @@ InternalUnitTester::~InternalUnitTester() {}
 ReturnValue_t InternalUnitTester::performTests(
         const struct InternalUnitTester::TestConfig& testConfig) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::info << "Running internal unit tests.." << std::endl;
+	sif::info << "Running internal unit tests.. Error messages might follow" <<
+	        std::endl;
 #else
 	sif::printInfo("Running internal unit tests..\n");
 #endif
 
 	testserialize::test_serialization();
 	testmq::testMq();
-	testsemaph::testBinSemaph();
-	testsemaph::testCountingSemaph();
+	if(testConfig.testSemaphores) {
+	    testsemaph::testBinSemaph();
+	    testsemaph::testCountingSemaph();
+	}
 	testmutex::testMutex();
 	if(testConfig.testArrayPrinter) {
 	    arrayprinter::testArrayPrinter();

tests/src/fsfw_tests/internal/InternalUnitTester.h

@@ -18,6 +18,7 @@ class InternalUnitTester: public HasReturnvaluesIF {
 public:
     struct TestConfig {
         bool testArrayPrinter = false;
+        bool testSemaphores = true;
     };
 
 	InternalUnitTester();

tests/src/fsfw_tests/internal/osal/IntTestMutex.cpp

@@ -1,10 +1,12 @@
 #include "fsfw_tests/internal/osal/IntTestMutex.h"
 #include "fsfw_tests/internal/UnittDefinitions.h"
+#include "fsfw/platform.h"
 
 #include <fsfw/ipc/MutexFactory.h>
 
-#if defined(WIN32) || defined(UNIX)
-#include <fsfw/osal/host/Mutex.h>
+#if defined PLATFORM_WIN || defined PLATFORM_UNIX
+#include "fsfw/osal/host/Mutex.h"
+
 #include <thread>
 #include <future>
 #endif
@@ -20,7 +22,7 @@ void testmutex::testMutex() {
 	// timed_mutex from the C++ library specifies undefined behaviour if
 	// the timed mutex is locked twice from the same thread.
     // TODO: we should pass a define like FSFW_OSAL_HOST to the build.
-#if defined(WIN32) || defined(UNIX)
+#if defined PLATFORM_WIN || defined PLATFORM_UNIX
 	// This calls the function from
 	// another thread and stores the returnvalue in a future.
 	auto future = std::async(&MutexIF::lockMutex, mutex, MutexIF::TimeoutType::WAITING, 1);
@@ -37,8 +39,7 @@ void testmutex::testMutex() {
 		unitt::put_error(id);
 	}
 
-	// TODO: we should pass a define like FSFW_OSAL_HOST to the build.
-#if !defined(WIN32) && !defined(UNIX)
+#if !defined PLATFORM_WIN && !defined PLATFORM_UNIX
     result = mutex->unlockMutex();
 	if(result != MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX) {
 		unitt::put_error(id);

tests/src/fsfw_tests/internal/osal/IntTestSemaphore.cpp

@@ -1,9 +1,10 @@
+#include "fsfw/FSFW.h"
 #include "fsfw_tests/internal/osal/IntTestSemaphore.h"
 #include "fsfw_tests/internal/UnittDefinitions.h"
 
-#include <fsfw/tasks/SemaphoreFactory.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-#include <fsfw/timemanager/Stopwatch.h>
+#include "fsfw/tasks/SemaphoreFactory.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/timemanager/Stopwatch.h"
 
 #include <cstdlib>
 
@@ -16,7 +17,7 @@ void testsemaph::testBinSemaph() {
 	}
 	testBinSemaphoreImplementation(binSemaph, id);
 	SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
-#if defined(freeRTOS)
+#if defined FSFW_OSAL_FREERTOS
 	SemaphoreIF* binSemaphUsingTask =
 			SemaphoreFactory::instance()->createBinarySemaphore(1);
 	testBinSemaphoreImplementation(binSemaphUsingTask, id);
@@ -36,7 +37,7 @@ void testsemaph::testCountingSemaph() {
 		}
 		testBinSemaphoreImplementation(countingSemaph, id);
 		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
-#if defined(freeRTOS)
+#if defined FSFW_OSAL_FREERTOS
 		countingSemaph = SemaphoreFactory::instance()->
 				createCountingSemaphore(1, 1, 1);
 		testBinSemaphoreImplementation(countingSemaph, id);
@@ -50,7 +51,7 @@ void testsemaph::testCountingSemaph() {
 				createCountingSemaphore(3,3);
 		testCountingSemaphImplementation(countingSemaph, id);
 		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
-#if defined(freeRTOS)
+#if defined FSFW_OSAL_FREERTOS
 		countingSemaph = SemaphoreFactory::instance()->
 				createCountingSemaphore(3, 0, 1);
 		uint8_t semaphCount = countingSemaph->getSemaphoreCounter();