diff --git a/CMakeLists.txt b/CMakeLists.txt index 27b456d..c8b09a2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,10 +1,8 @@ add_subdirectory(config) add_subdirectory(example) -target_include_directories(${TARGET_NAME} PRIVATE - ${CMAKE_CURRENT_SOURCE_DIR} -) +target_include_directories(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) if(TGT_BSP MATCHES "arm/stm32h743zi-nucleo") - add_subdirectory(stm32h7) + add_subdirectory(stm32h7) endif() diff --git a/cmake/BuildType.cmake b/cmake/BuildType.cmake new file mode 100644 index 0000000..e078e5c --- /dev/null +++ b/cmake/BuildType.cmake @@ -0,0 +1,45 @@ +function(set_build_type) + +message(STATUS "Used build generator: ${CMAKE_GENERATOR}") + +# Set a default build type if none was specified +set(DEFAULT_BUILD_TYPE "RelWithDebInfo") +if(EXISTS "${CMAKE_SOURCE_DIR}/.git") + set(DEFAULT_BUILD_TYPE "Debug") +endif() + +if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + message(STATUS + "Setting build type to '${DEFAULT_BUILD_TYPE}' as none was specified." + ) + set(CMAKE_BUILD_TYPE "${DEFAULT_BUILD_TYPE}" CACHE + STRING "Choose the type of build." FORCE + ) + # Set the possible values of build type for cmake-gui + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Release" "MinSizeRel" "RelWithDebInfo" + ) +endif() + +if(${CMAKE_BUILD_TYPE} MATCHES "Debug") + message(STATUS + "Building Debug application with flags: ${CMAKE_C_FLAGS_DEBUG}" + ) +elseif(${CMAKE_BUILD_TYPE} MATCHES "RelWithDebInfo") + message(STATUS + "Building Release (Debug) application with " + "flags: ${CMAKE_C_FLAGS_RELWITHDEBINFO}" + ) +elseif(${CMAKE_BUILD_TYPE} MATCHES "MinSizeRel") + message(STATUS + "Building Release (Size) application with " + "flags: ${CMAKE_C_FLAGS_MINSIZEREL}" + ) +else() + message(STATUS + "Building Release (Speed) application with " + "flags: ${CMAKE_C_FLAGS_RELEASE}" + ) +endif() + +endfunction() diff --git a/cmake/common.cmake b/cmake/common.cmake new file mode 100644 index 0000000..cb2a530 --- /dev/null +++ b/cmake/common.cmake @@ -0,0 +1,42 @@ +function(get_common_build_flags TGT_NAME) + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + set(COMMON_COMPILE_OPTS + -ffunction-sections + -fdata-sections + PARENT_SCOPE) + set(COMMON_LINK_OPTS + -Wl,--gc-sections + -Wl,-Map=${TARGET_NAME}.map + PARENT_SCOPE) + set(COMMON_WARNING_FLAGS + -Wall + -Wextra + -Wimplicit-fallthrough=1 + -Wno-unused-parameter + -Wno-psabi + -Wduplicated-cond # check for duplicate conditions + -Wduplicated-branches # check for duplicate branches + -Wlogical-op # Search for bitwise operations instead of logical + -Wnull-dereference # Search for NULL dereference + -Wundef # Warn if undefind marcos are used + -Wformat=2 # Format string problem detection + -Wformat-overflow=2 # Formatting issues in printf + -Wformat-truncation=2 # Formatting issues in printf + -Wformat-security # Search for dangerous printf operations + -Wstrict-overflow=3 # Warn if integer overflows might happen + -Warray-bounds=2 # Some array bounds violations will be found + -Wshift-overflow=2 # Search for bit left shift overflows ( + +/** + * Enumerations for used PUS service IDs. + */ +namespace pus { +enum ServiceIds : uint8_t { + PUS_SERVICE_1 = 1, + PUS_SERVICE_2 = 2, + PUS_SERVICE_3 = 3, + PUS_SERVICE_5 = 5, + PUS_SERVICE_8 = 8, + PUS_SERVICE_9 = 9, + PUS_SERVICE_11 = 11, + PUS_SERVICE_17 = 17, + PUS_SERVICE_20 = 20, + PUS_SERVICE_200 = 200 +}; +} diff --git a/config/commonClassIds.h b/config/commonClassIds.h index 75b2cbd..1f2b8fb 100644 --- a/config/commonClassIds.h +++ b/config/commonClassIds.h @@ -6,8 +6,8 @@ namespace CLASS_ID { enum commonClassIds : uint8_t { COMMON_CLASS_ID_START = FW_CLASS_ID_COUNT, - DUMMY_HANDLER, // DDH - COMMON_CLASS_ID_END // [EXPORT] : [END] + DUMMY_HANDLER, // DDH + COMMON_CLASS_ID_END // [EXPORT] : [END] }; } diff --git a/config/commonConfig.h.in b/config/commonConfig.h.in index af89d1e..163b631 100644 --- a/config/commonConfig.h.in +++ b/config/commonConfig.h.in @@ -10,7 +10,7 @@ //! Specify the debug output verbose level #define OBSW_VERBOSE_LEVEL 1 - +#define OBSW_TCPIP_UDP_WIRETAPPING 0 #define OBSW_PRINT_MISSED_DEADLINES 0 //! Perform internal unit testd at application startup @@ -44,24 +44,10 @@ static const uint16_t COMMON_APID = 0xEF; #ifdef __cplusplus -#include -#include +namespace cfg { + +static constexpr uint32_t OBSW_MAX_SCHEDULED_TCS = @OBSW_MAX_SCHEDULED_TCS@; -/** - * Enumerations for used PUS service IDs. - */ -namespace pus { -enum ServiceIds: uint8_t { - PUS_SERVICE_1 = 1, - PUS_SERVICE_2 = 2, - PUS_SERVICE_3 = 3, - PUS_SERVICE_5 = 5, - PUS_SERVICE_8 = 8, - PUS_SERVICE_9 = 9, - PUS_SERVICE_17 = 17, - PUS_SERVICE_20 = 20, - PUS_SERVICE_200 = 200 -}; } #endif /* __cplusplus */ diff --git a/config/commonSystemObjects.h b/config/commonObjects.h similarity index 100% rename from config/commonSystemObjects.h rename to config/commonObjects.h diff --git a/config/commonPollingSequenceFactory.cpp b/config/commonPollingSequenceFactory.cpp index c2497ce..d376d31 100644 --- a/config/commonPollingSequenceFactory.cpp +++ b/config/commonPollingSequenceFactory.cpp @@ -6,12 +6,15 @@ #include "objects/systemObjectList.h" #include "pollingsequence/pollingSequenceFactory.h" -ReturnValue_t pst::pollingSequenceExamples(FixedTimeslotTaskIF* thisSequence) { +ReturnValue_t pst::pollingSequenceExamples(FixedTimeslotTaskIF *thisSequence) { uint32_t length = thisSequence->getPeriodMs(); - thisSequence->addSlot(objects::TEST_DUMMY_1, length * 0, FsfwExampleTask::OpCodes::SEND_RAND_NUM); - thisSequence->addSlot(objects::TEST_DUMMY_2, length * 0, FsfwExampleTask::OpCodes::SEND_RAND_NUM); - thisSequence->addSlot(objects::TEST_DUMMY_3, length * 0, FsfwExampleTask::OpCodes::SEND_RAND_NUM); + thisSequence->addSlot(objects::TEST_DUMMY_1, length * 0, + FsfwExampleTask::OpCodes::SEND_RAND_NUM); + thisSequence->addSlot(objects::TEST_DUMMY_2, length * 0, + FsfwExampleTask::OpCodes::SEND_RAND_NUM); + thisSequence->addSlot(objects::TEST_DUMMY_3, length * 0, + FsfwExampleTask::OpCodes::SEND_RAND_NUM); thisSequence->addSlot(objects::TEST_DUMMY_1, length * 0.2, FsfwExampleTask::OpCodes::RECEIVE_RAND_NUM); @@ -20,9 +23,12 @@ ReturnValue_t pst::pollingSequenceExamples(FixedTimeslotTaskIF* thisSequence) { thisSequence->addSlot(objects::TEST_DUMMY_3, length * 0.2, FsfwExampleTask::OpCodes::RECEIVE_RAND_NUM); - thisSequence->addSlot(objects::TEST_DUMMY_1, length * 0.5, FsfwExampleTask::OpCodes::DELAY_SHORT); - thisSequence->addSlot(objects::TEST_DUMMY_2, length * 0.5, FsfwExampleTask::OpCodes::DELAY_SHORT); - thisSequence->addSlot(objects::TEST_DUMMY_3, length * 0.5, FsfwExampleTask::OpCodes::DELAY_SHORT); + thisSequence->addSlot(objects::TEST_DUMMY_1, length * 0.5, + FsfwExampleTask::OpCodes::DELAY_SHORT); + thisSequence->addSlot(objects::TEST_DUMMY_2, length * 0.5, + FsfwExampleTask::OpCodes::DELAY_SHORT); + thisSequence->addSlot(objects::TEST_DUMMY_3, length * 0.5, + FsfwExampleTask::OpCodes::DELAY_SHORT); if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) { return HasReturnvaluesIF::RETURN_OK; @@ -32,23 +38,33 @@ ReturnValue_t pst::pollingSequenceExamples(FixedTimeslotTaskIF* thisSequence) { } } -ReturnValue_t pst::pollingSequenceDevices(FixedTimeslotTaskIF* thisSequence) { +ReturnValue_t pst::pollingSequenceDevices(FixedTimeslotTaskIF *thisSequence) { uint32_t length = thisSequence->getPeriodMs(); - thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0, DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0, + DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0, + DeviceHandlerIF::PERFORM_OPERATION); - thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.3 * length, DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.3 * length, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.3 * length, + DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.3 * length, + DeviceHandlerIF::SEND_WRITE); - thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.45 * length, DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.45 * length, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.45 * length, + DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.45 * length, + DeviceHandlerIF::GET_WRITE); - thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.6 * length, DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.6 * length, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.6 * length, + DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.6 * length, + DeviceHandlerIF::SEND_READ); - thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.8 * length, DeviceHandlerIF::GET_READ); - thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.8 * length, DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.8 * length, + DeviceHandlerIF::GET_READ); + thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.8 * length, + DeviceHandlerIF::GET_READ); if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) { return HasReturnvaluesIF::RETURN_OK; diff --git a/example/controller/CMakeLists.txt b/example/controller/CMakeLists.txt index 355a328..1f09655 100644 --- a/example/controller/CMakeLists.txt +++ b/example/controller/CMakeLists.txt @@ -1,3 +1 @@ -target_sources(${TARGET_NAME} PRIVATE - FsfwTestController.cpp -) +target_sources(${TARGET_NAME} PRIVATE FsfwTestController.cpp) diff --git a/example/controller/FsfwTestController.cpp b/example/controller/FsfwTestController.cpp index 5b45875..28c7361 100644 --- a/example/controller/FsfwTestController.cpp +++ b/example/controller/FsfwTestController.cpp @@ -2,22 +2,21 @@ #include -FsfwTestController::FsfwTestController(object_id_t objectId, object_id_t device0, - object_id_t device1, uint8_t verboseLevel) - : TestController(objectId, objects::NO_OBJECT, 5), - device0Id(device0), - device1Id(device1), - deviceDataset0(device0), - deviceDataset1(device1) {} +FsfwTestController::FsfwTestController(object_id_t objectId, + object_id_t device0, object_id_t device1, + uint8_t verboseLevel) + : TestController(objectId, objects::NO_OBJECT, 5), device0Id(device0), + device1Id(device1), deviceDataset0(device0), deviceDataset1(device1) {} FsfwTestController::~FsfwTestController() {} -ReturnValue_t FsfwTestController::handleCommandMessage(CommandMessage* message) { +ReturnValue_t +FsfwTestController::handleCommandMessage(CommandMessage *message) { return HasReturnvaluesIF::RETURN_OK; } -ReturnValue_t FsfwTestController::initializeLocalDataPool(localpool::DataPool& localDataPoolMap, - LocalDataPoolManager& poolManager) { +ReturnValue_t FsfwTestController::initializeLocalDataPool( + localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) { return HasReturnvaluesIF::RETURN_OK; } @@ -64,13 +63,14 @@ ReturnValue_t FsfwTestController::initializeAfterTaskCreation() { FSFW_LOGW("initializeAfterTaskCreation: Test device handler 0 handle invalid\n"); return ObjectManagerIF::CHILD_INIT_FAILED; } - ProvidesDataPoolSubscriptionIF* subscriptionIF = device0->getSubscriptionInterface(); + ProvidesDataPoolSubscriptionIF *subscriptionIF = + device0->getSubscriptionInterface(); if (subscriptionIF != nullptr) { /* For DEVICE_0, we only subscribe for notifications */ - subscriptionIF->subscribeForSetUpdateMessage(td::TEST_SET_ID, getObjectId(), getCommandQueue(), - false); - subscriptionIF->subscribeForVariableUpdateMessage(td::PoolIds::TEST_UINT8_ID, getObjectId(), - getCommandQueue(), false); + subscriptionIF->subscribeForSetUpdateMessage(td::TEST_SET_ID, getObjectId(), + getCommandQueue(), false); + subscriptionIF->subscribeForVariableUpdateMessage( + td::PoolIds::TEST_UINT8_ID, getObjectId(), getCommandQueue(), false); } auto* device1 = @@ -82,27 +82,31 @@ ReturnValue_t FsfwTestController::initializeAfterTaskCreation() { subscriptionIF = device1->getSubscriptionInterface(); if (subscriptionIF != nullptr) { /* For DEVICE_1, we will subscribe for snapshots */ - subscriptionIF->subscribeForSetUpdateMessage(td::TEST_SET_ID, getObjectId(), getCommandQueue(), - true); - subscriptionIF->subscribeForVariableUpdateMessage(td::PoolIds::TEST_UINT8_ID, getObjectId(), - getCommandQueue(), true); + subscriptionIF->subscribeForSetUpdateMessage(td::TEST_SET_ID, getObjectId(), + getCommandQueue(), true); + subscriptionIF->subscribeForVariableUpdateMessage( + td::PoolIds::TEST_UINT8_ID, getObjectId(), getCommandQueue(), true); } return result; } -LocalPoolDataSetBase* FsfwTestController::getDataSetHandle(sid_t sid) { return nullptr; } +LocalPoolDataSetBase *FsfwTestController::getDataSetHandle(sid_t sid) { + return nullptr; +} -ReturnValue_t FsfwTestController::checkModeCommand(Mode_t mode, Submode_t submode, - uint32_t* msToReachTheMode) { +ReturnValue_t FsfwTestController::checkModeCommand(Mode_t mode, + Submode_t submode, + uint32_t *msToReachTheMode) { return HasReturnvaluesIF::RETURN_OK; } -void FsfwTestController::handleChangedDataset(sid_t sid, store_address_t storeId, - bool* clearMessage) { +void FsfwTestController::handleChangedDataset(sid_t sid, + store_address_t storeId, + bool *clearMessage) { using namespace std; if (verboseLevel >= 1) { - char const* printout = nullptr; + char const *printout = nullptr; if (storeId == storeId::INVALID_STORE_ADDRESS) { printout = "Notification"; } else { @@ -132,12 +136,13 @@ void FsfwTestController::handleChangedDataset(sid_t sid, store_address_t storeId } } -void FsfwTestController::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId, - bool* clearMessage) { +void FsfwTestController::handleChangedPoolVariable(gp_id_t globPoolId, + store_address_t storeId, + bool *clearMessage) { using namespace std; if (verboseLevel >= 1) { - char const* printout = nullptr; + char const *printout = nullptr; if (storeId == storeId::INVALID_STORE_ADDRESS) { printout = "Notification"; } else { diff --git a/example/controller/FsfwTestController.h b/example/controller/FsfwTestController.h index 38c4d0b..614ee10 100644 --- a/example/controller/FsfwTestController.h +++ b/example/controller/FsfwTestController.h @@ -5,18 +5,18 @@ #include "fsfw_tests/integration/controller/TestController.h" class FsfwTestController : public TestController { - public: - FsfwTestController(object_id_t objectId, object_id_t device0, object_id_t device1, - uint8_t verboseLevel = 0); +public: + FsfwTestController(object_id_t objectId, object_id_t device0, + object_id_t device1, uint8_t verboseLevel = 0); virtual ~FsfwTestController(); - ReturnValue_t handleCommandMessage(CommandMessage* message) override; + ReturnValue_t handleCommandMessage(CommandMessage *message) override; /** * Periodic helper from ControllerBase, implemented by child class. */ void performControlOperation() override; - private: +private: object_id_t device0Id; object_id_t device1Id; testdevice::TestDataSet deviceDataset0; @@ -31,14 +31,16 @@ class FsfwTestController : public TestController { TraceTypes currentTraceType = TraceTypes::NONE; ReturnValue_t initializeAfterTaskCreation() override; - void handleChangedDataset(sid_t sid, store_address_t storeId, bool* clearMessage) override; + void handleChangedDataset(sid_t sid, store_address_t storeId, + bool *clearMessage) override; void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId, - bool* clearMessage) override; - ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap, - LocalDataPoolManager& poolManager) override; - LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override; + bool *clearMessage) override; + 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) override; + uint32_t *msToReachTheMode) override; }; #endif /* EXAMPLE_COMMON_EXAMPLE_CONTROLLER_FSFWTESTCONTROLLER_H_ */ diff --git a/example/core/CMakeLists.txt b/example/core/CMakeLists.txt index 22e0f41..af0fc0e 100644 --- a/example/core/CMakeLists.txt +++ b/example/core/CMakeLists.txt @@ -1,3 +1 @@ -target_sources(${TARGET_NAME} PRIVATE - GenericFactory.cpp -) +target_sources(${TARGET_NAME} PRIVATE GenericFactory.cpp) diff --git a/example/core/GenericFactory.cpp b/example/core/GenericFactory.cpp index 168856e..b4f6acf 100644 --- a/example/core/GenericFactory.cpp +++ b/example/core/GenericFactory.cpp @@ -1,6 +1,7 @@ #include "GenericFactory.h" #include "OBSWConfig.h" +#include "common/definitions.h" #include "example/test/FsfwExampleTask.h" #include "example/test/FsfwReaderTask.h" #include "example/utility/TmFunnel.h" @@ -10,6 +11,7 @@ #include "fsfw/health/HealthTable.h" #include "fsfw/internalerror/InternalErrorReporter.h" #include "fsfw/pus/CService200ModeCommanding.h" +#include "fsfw/pus/Service11TelecommandScheduling.h" #include "fsfw/pus/Service17Test.h" #include "fsfw/pus/Service1TelecommandVerification.h" #include "fsfw/pus/Service20ParameterManagement.h" @@ -30,7 +32,6 @@ #include "fsfw_tests/internal/InternalUnitTester.h" #include "objects/systemObjectList.h" #include "tmtc/apid.h" -#include "tmtc/pusIds.h" void ObjectFactory::produceGenericObjects() { #if OBSW_ADD_CORE_COMPONENTS == 1 @@ -39,26 +40,37 @@ void ObjectFactory::produceGenericObjects() { new HealthTable(objects::HEALTH_TABLE); new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER); new TimeStamper(objects::TIME_STAMPER); - new CCSDSDistributor(apid::APID, objects::CCSDS_DISTRIBUTOR); - new PUSDistributor(apid::APID, objects::PUS_DISTRIBUTOR, objects::CCSDS_DISTRIBUTOR); + auto *ccsdsDistrib = + new CCSDSDistributor(apid::APID, objects::CCSDS_DISTRIBUTOR); + new PUSDistributor(apid::APID, objects::PUS_DISTRIBUTOR, + objects::CCSDS_DISTRIBUTOR); new TmFunnel(objects::TM_FUNNEL); #endif /* OBSW_ADD_CORE_COMPONENTS == 1 */ /* PUS stack */ #if OBSW_ADD_PUS_STACK == 1 - new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION, apid::APID, - pus::PUS_SERVICE_1, objects::TM_FUNNEL, 5); - new Service2DeviceAccess(objects::PUS_SERVICE_2_DEVICE_ACCESS, apid::APID, pus::PUS_SERVICE_2, 3, - 10); - new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, apid::APID, pus::PUS_SERVICE_3); - new Service5EventReporting(objects::PUS_SERVICE_5_EVENT_REPORTING, apid::APID, pus::PUS_SERVICE_5, - 50); - new Service8FunctionManagement(objects::PUS_SERVICE_8_FUNCTION_MGMT, apid::APID, - pus::PUS_SERVICE_8, 3, 10); - new Service9TimeManagement(objects::PUS_SERVICE_9_TIME_MGMT, apid::APID, pus::PUS_SERVICE_9); - new Service17Test(objects::PUS_SERVICE_17_TEST, apid::APID, pus::PUS_SERVICE_17); - new Service20ParameterManagement(objects::PUS_SERVICE_20_PARAMETERS, apid::APID, - pus::PUS_SERVICE_20); + new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION, + apid::APID, pus::PUS_SERVICE_1, + objects::TM_FUNNEL, 5); + new Service2DeviceAccess(objects::PUS_SERVICE_2_DEVICE_ACCESS, apid::APID, + pus::PUS_SERVICE_2, 3, 10); + new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, apid::APID, + pus::PUS_SERVICE_3); + new Service5EventReporting(objects::PUS_SERVICE_5_EVENT_REPORTING, apid::APID, + pus::PUS_SERVICE_5, 50); + new Service8FunctionManagement(objects::PUS_SERVICE_8_FUNCTION_MGMT, + apid::APID, pus::PUS_SERVICE_8, 3, 10); + new Service9TimeManagement(objects::PUS_SERVICE_9_TIME_MGMT, apid::APID, + pus::PUS_SERVICE_9); + new Service17Test(objects::PUS_SERVICE_17_TEST, apid::APID, + pus::PUS_SERVICE_17); + new Service20ParameterManagement(objects::PUS_SERVICE_20_PARAMETERS, + apid::APID, pus::PUS_SERVICE_20); +#if OBSW_ADD_CORE_COMPONENTS == 1 + new Service11TelecommandScheduling( + objects::PUS_SERVICE_11_TC_SCHEDULER, apid::APID, pus::PUS_SERVICE_11, + ccsdsDistrib); +#endif new CService200ModeCommanding(objects::PUS_SERVICE_200_MODE_MGMT, apid::APID, pus::PUS_SERVICE_200); #endif /* OBSW_ADD_PUS_STACK == 1 */ @@ -86,17 +98,22 @@ void ObjectFactory::produceGenericObjects() { /* Demo device handler object */ size_t expectedMaxReplyLen = 64; - CookieIF* testCookie = new TestCookie(static_cast(testdevice::DeviceIndex::DEVICE_0), - expectedMaxReplyLen); + CookieIF *testCookie = + new TestCookie(static_cast(testdevice::DeviceIndex::DEVICE_0), + expectedMaxReplyLen); new TestEchoComIF(objects::TEST_ECHO_COM_IF); - new TestDevice(objects::TEST_DEVICE_HANDLER_0, objects::TEST_ECHO_COM_IF, testCookie, - testdevice::DeviceIndex::DEVICE_0, enableInfoPrintout); - testCookie = new TestCookie(static_cast(testdevice::DeviceIndex::DEVICE_1), - expectedMaxReplyLen); - new TestDevice(objects::TEST_DEVICE_HANDLER_1, objects::TEST_ECHO_COM_IF, testCookie, - testdevice::DeviceIndex::DEVICE_1, enableInfoPrintout); + new TestDevice(objects::TEST_DEVICE_HANDLER_0, objects::TEST_ECHO_COM_IF, + testCookie, testdevice::DeviceIndex::DEVICE_0, + enableInfoPrintout); + testCookie = + new TestCookie(static_cast(testdevice::DeviceIndex::DEVICE_1), + expectedMaxReplyLen); + new TestDevice(objects::TEST_DEVICE_HANDLER_1, objects::TEST_ECHO_COM_IF, + testCookie, testdevice::DeviceIndex::DEVICE_1, + enableInfoPrintout); - new TestAssembly(objects::TEST_ASSEMBLY, objects::NO_OBJECT, objects::TEST_DEVICE_HANDLER_0, + new TestAssembly(objects::TEST_ASSEMBLY, objects::NO_OBJECT, + objects::TEST_DEVICE_HANDLER_0, objects::TEST_DEVICE_HANDLER_1); #endif /* OBSW_ADD_DEVICE_HANDLER_DEMO == 1 */ diff --git a/example/core/GenericFactory.h b/example/core/GenericFactory.h index 3cf5d41..4bbcf2c 100644 --- a/example/core/GenericFactory.h +++ b/example/core/GenericFactory.h @@ -11,6 +11,6 @@ namespace ObjectFactory { */ void produceGenericObjects(); -} // namespace ObjectFactory +} // namespace ObjectFactory #endif /* MISSION_CORE_GENERICFACTORY_H_ */ diff --git a/example/devices/CMakeLists.txt b/example/devices/CMakeLists.txt index e69de29..8b13789 100644 --- a/example/devices/CMakeLists.txt +++ b/example/devices/CMakeLists.txt @@ -0,0 +1 @@ + diff --git a/example/test/CMakeLists.txt b/example/test/CMakeLists.txt index 6f512d0..3a486c8 100644 --- a/example/test/CMakeLists.txt +++ b/example/test/CMakeLists.txt @@ -1,9 +1,5 @@ -target_sources(${TARGET_NAME} PRIVATE - FsfwReaderTask.cpp - FsfwExampleTask.cpp - MutexExample.cpp - FsfwTestTask.cpp -) +target_sources(${TARGET_NAME} PRIVATE FsfwReaderTask.cpp FsfwExampleTask.cpp + MutexExample.cpp FsfwTestTask.cpp) if(OBSW_ADD_FMT_TESTS) target_sources(${TARGET_NAME} PRIVATE diff --git a/example/test/FsfwExampleTask.cpp b/example/test/FsfwExampleTask.cpp index b47ab64..c937ded 100644 --- a/example/test/FsfwExampleTask.cpp +++ b/example/test/FsfwExampleTask.cpp @@ -7,15 +7,15 @@ #include #include "OBSWConfig.h" -#include "commonSystemObjects.h" +#include "commonObjects.h" #include "objects/systemObjectList.h" FsfwExampleTask::FsfwExampleTask(object_id_t objectId) - : SystemObject(objectId), - poolManager(this, nullptr), - demoSet(this), - monitor(objectId, MONITOR_ID, gp_id_t(objectId, FsfwDemoSet::VARIABLE_LIMIT), 30, 10) { - commandQueue = QueueFactory::instance()->createMessageQueue(10, CommandMessage::MAX_MESSAGE_SIZE); + : SystemObject(objectId), poolManager(this, nullptr), demoSet(this), + monitor(objectId, MONITOR_ID, + gp_id_t(objectId, FsfwDemoSet::VARIABLE_LIMIT), 30, 10) { + commandQueue = QueueFactory::instance()->createMessageQueue( + 10, CommandMessage::MAX_MESSAGE_SIZE); } FsfwExampleTask::~FsfwExampleTask() {} @@ -47,33 +47,33 @@ ReturnValue_t FsfwExampleTask::performOperation(uint8_t operationCode) { object_id_t FsfwExampleTask::getNextRecipient() { switch (this->getObjectId()) { - case (objects::TEST_DUMMY_1): { - return objects::TEST_DUMMY_2; - } - case (objects::TEST_DUMMY_2): { - return objects::TEST_DUMMY_3; - } - case (objects::TEST_DUMMY_3): { - return objects::TEST_DUMMY_1; - } - default: - return objects::TEST_DUMMY_1; + case (objects::TEST_DUMMY_1): { + return objects::TEST_DUMMY_2; + } + case (objects::TEST_DUMMY_2): { + return objects::TEST_DUMMY_3; + } + case (objects::TEST_DUMMY_3): { + return objects::TEST_DUMMY_1; + } + default: + return objects::TEST_DUMMY_1; } } object_id_t FsfwExampleTask::getSender() { switch (this->getObjectId()) { - case (objects::TEST_DUMMY_1): { - return objects::TEST_DUMMY_3; - } - case (objects::TEST_DUMMY_2): { - return objects::TEST_DUMMY_1; - } - case (objects::TEST_DUMMY_3): { - return objects::TEST_DUMMY_2; - } - default: - return objects::TEST_DUMMY_1; + case (objects::TEST_DUMMY_1): { + return objects::TEST_DUMMY_3; + } + case (objects::TEST_DUMMY_2): { + return objects::TEST_DUMMY_1; + } + case (objects::TEST_DUMMY_3): { + return objects::TEST_DUMMY_2; + } + default: + return objects::TEST_DUMMY_1; } } @@ -86,7 +86,8 @@ ReturnValue_t FsfwExampleTask::initialize() { return HasReturnvaluesIF::RETURN_FAILED; } - // we need a private copy of the previous dataset.. or we use the shared dataset. + // we need a private copy of the previous dataset.. or we use the shared + // dataset. senderSet = new FsfwDemoSet(senderIF); if (senderSet == nullptr) { FSFW_LOGE("initialize: Sender dataset invalid\n"); @@ -99,25 +100,37 @@ ReturnValue_t FsfwExampleTask::initializeAfterTaskCreation() { return poolManager.initializeAfterTaskCreation(); } -object_id_t FsfwExampleTask::getObjectId() const { return SystemObject::getObjectId(); } +object_id_t FsfwExampleTask::getObjectId() const { + return SystemObject::getObjectId(); +} -MessageQueueId_t FsfwExampleTask::getMessageQueueId() { return commandQueue->getId(); } +MessageQueueId_t FsfwExampleTask::getMessageQueueId() { + return commandQueue->getId(); +} -void FsfwExampleTask::setTaskIF(PeriodicTaskIF* task) { this->task = task; } +void FsfwExampleTask::setTaskIF(PeriodicTaskIF *task) { this->task = task; } -LocalPoolDataSetBase* FsfwExampleTask::getDataSetHandle(sid_t sid) { return &demoSet; } +LocalPoolDataSetBase *FsfwExampleTask::getDataSetHandle(sid_t sid) { + return &demoSet; +} -uint32_t FsfwExampleTask::getPeriodicOperationFrequency() const { return task->getPeriodMs(); } +uint32_t FsfwExampleTask::getPeriodicOperationFrequency() const { + return task->getPeriodMs(); +} -ReturnValue_t FsfwExampleTask::initializeLocalDataPool(localpool::DataPool& localDataPoolMap, - LocalDataPoolManager& poolManager) { - localDataPoolMap.emplace(FsfwDemoSet::PoolIds::VARIABLE, new PoolEntry({0})); - localDataPoolMap.emplace(FsfwDemoSet::PoolIds::VARIABLE_LIMIT, new PoolEntry({0})); +ReturnValue_t +FsfwExampleTask::initializeLocalDataPool(localpool::DataPool &localDataPoolMap, + LocalDataPoolManager &poolManager) { + localDataPoolMap.emplace(FsfwDemoSet::PoolIds::VARIABLE, + new PoolEntry({0})); + localDataPoolMap.emplace(FsfwDemoSet::PoolIds::VARIABLE_LIMIT, + new PoolEntry({0})); return HasReturnvaluesIF::RETURN_OK; } ReturnValue_t FsfwExampleTask::performMonitoringDemo() { - ReturnValue_t result = demoSet.variableLimit.read(MutexIF::TimeoutType::WAITING, 20); + ReturnValue_t result = + demoSet.variableLimit.read(MutexIF::TimeoutType::WAITING, 20); if (result != HasReturnvaluesIF::RETURN_OK) { /* Configuration error */ FSFW_LOGE("DummyObject::performOperation: Could not read variableLimit\n"); @@ -180,8 +193,9 @@ ReturnValue_t FsfwExampleTask::performReceiveOperation() { #if FSFW_CPP_OSTREAM_ENABLED == 1 #if OBSW_VERBOSE_LEVEL >= 2 sif::debug << "Message Received by " << getObjectId() << " from Queue " - << receivedMessage.getSender() << " ObjectId " << receivedMessage.getParameter() - << " Queue " << receivedMessage.getParameter2() << std::endl; + << receivedMessage.getSender() << " ObjectId " + << receivedMessage.getParameter() << " Queue " + << receivedMessage.getParameter2() << std::endl; #endif #endif @@ -204,6 +218,10 @@ ReturnValue_t FsfwExampleTask::performReceiveOperation() { return result; } -MessageQueueId_t FsfwExampleTask::getCommandQueue() const { return commandQueue->getId(); } +MessageQueueId_t FsfwExampleTask::getCommandQueue() const { + return commandQueue->getId(); +} -LocalDataPoolManager* FsfwExampleTask::getHkManagerHandle() { return &poolManager; } +LocalDataPoolManager *FsfwExampleTask::getHkManagerHandle() { + return &poolManager; +} diff --git a/example/test/FsfwExampleTask.h b/example/test/FsfwExampleTask.h index 9d2cb52..345d2f3 100644 --- a/example/test/FsfwExampleTask.h +++ b/example/test/FsfwExampleTask.h @@ -24,8 +24,10 @@ class PeriodicTaskIF; * value directly from the sender via the local data pool interface. * If the timing is set up correctly, the values will always be the same. */ -class FsfwExampleTask : public ExecutableObjectIF, public SystemObject, public HasLocalDataPoolIF { - public: +class FsfwExampleTask : public ExecutableObjectIF, + public SystemObject, + public HasLocalDataPoolIF { +public: enum OpCodes { SEND_RAND_NUM, RECEIVE_RAND_NUM, DELAY_SHORT }; static constexpr uint8_t MONITOR_ID = 2; @@ -72,27 +74,28 @@ class FsfwExampleTask : public ExecutableObjectIF, public SystemObject, public H * task interface handle can be cached to access task specific properties. * @param task */ - void setTaskIF(PeriodicTaskIF* task) override; + void setTaskIF(PeriodicTaskIF *task) override; object_id_t getObjectId() const override; MessageQueueId_t getMessageQueueId(); - private: +private: LocalDataPoolManager poolManager; - FsfwDemoSet* senderSet = nullptr; + FsfwDemoSet *senderSet = nullptr; FsfwDemoSet demoSet; AbsLimitMonitor monitor; - PeriodicTaskIF* task = nullptr; - MessageQueueIF* commandQueue = nullptr; + PeriodicTaskIF *task = nullptr; + MessageQueueIF *commandQueue = nullptr; /* HasLocalDatapoolIF overrides */ MessageQueueId_t getCommandQueue() const override; - LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override; + LocalPoolDataSetBase *getDataSetHandle(sid_t sid) override; uint32_t getPeriodicOperationFrequency() const override; - ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap, - LocalDataPoolManager& poolManager) override; - LocalDataPoolManager* getHkManagerHandle() override; + ReturnValue_t + initializeLocalDataPool(localpool::DataPool &localDataPoolMap, + LocalDataPoolManager &poolManager) override; + LocalDataPoolManager *getHkManagerHandle() override; object_id_t getNextRecipient(); object_id_t getSender(); diff --git a/example/test/FsfwReaderTask.cpp b/example/test/FsfwReaderTask.cpp index 51861c6..0bab27c 100644 --- a/example/test/FsfwReaderTask.cpp +++ b/example/test/FsfwReaderTask.cpp @@ -7,13 +7,13 @@ #include FsfwReaderTask::FsfwReaderTask(object_id_t objectId, bool enablePrintout) - : SystemObject(objectId), - printoutEnabled(enablePrintout), - opDivider(10), - readSet(this->getObjectId(), gp_id_t(objects::TEST_DUMMY_1, FsfwDemoSet::PoolIds::VARIABLE), + : SystemObject(objectId), printoutEnabled(enablePrintout), opDivider(10), + readSet(this->getObjectId(), + gp_id_t(objects::TEST_DUMMY_1, FsfwDemoSet::PoolIds::VARIABLE), gp_id_t(objects::TEST_DUMMY_2, FsfwDemoSet::PoolIds::VARIABLE), gp_id_t(objects::TEST_DUMMY_3, FsfwDemoSet::PoolIds::VARIABLE)) { - /* Special protection for set reading because each variable is read from a different pool */ + /* Special protection for set reading because each variable is read from a + * different pool */ readSet.setReadCommitProtectionBehaviour(true); } diff --git a/example/test/FsfwReaderTask.h b/example/test/FsfwReaderTask.h index 419435e..636e9b9 100644 --- a/example/test/FsfwReaderTask.h +++ b/example/test/FsfwReaderTask.h @@ -8,14 +8,14 @@ #include "testdefinitions/demoDefinitions.h" class FsfwReaderTask : public ExecutableObjectIF, public SystemObject { - public: +public: FsfwReaderTask(object_id_t objectId, bool enablePrintout); ~FsfwReaderTask() override; ReturnValue_t initializeAfterTaskCreation() override; ReturnValue_t performOperation(uint8_t operationCode = 0) override; - private: +private: bool printoutEnabled = false; PeriodicOperationDivider opDivider; CompleteDemoReadSet readSet; diff --git a/example/test/FsfwTestTask.h b/example/test/FsfwTestTask.h index 285add9..24125b1 100644 --- a/example/test/FsfwTestTask.h +++ b/example/test/FsfwTestTask.h @@ -6,15 +6,16 @@ #include "fsfw_tests/integration/task/TestTask.h" class FsfwTestTask : public TestTask { - public: +public: FsfwTestTask(object_id_t objectId, bool periodicEvent); ReturnValue_t performPeriodicAction() override; - private: +private: bool periodicEvent = false; static constexpr uint8_t subsystemId = SUBSYSTEM_ID::TEST_TASK_ID; - static constexpr Event TEST_EVENT = event::makeEvent(subsystemId, 0, severity::INFO); + static constexpr Event TEST_EVENT = + event::makeEvent(subsystemId, 0, severity::INFO); }; #endif /* EXAMPLE_COMMON_EXAMPLE_TEST_FSFWTESTTASK_H_ */ diff --git a/example/test/MutexExample.cpp b/example/test/MutexExample.cpp index b429802..f8edba3 100644 --- a/example/test/MutexExample.cpp +++ b/example/test/MutexExample.cpp @@ -4,10 +4,11 @@ #include void MutexExample::example() { - MutexIF* mutex = MutexFactory::instance()->createMutex(); - MutexIF* mutex2 = MutexFactory::instance()->createMutex(); + MutexIF *mutex = MutexFactory::instance()->createMutex(); + MutexIF *mutex2 = MutexFactory::instance()->createMutex(); - ReturnValue_t result = mutex->lockMutex(MutexIF::TimeoutType::WAITING, 2 * 60 * 1000); + ReturnValue_t result = + mutex->lockMutex(MutexIF::TimeoutType::WAITING, 2 * 60 * 1000); if (result != HasReturnvaluesIF::RETURN_OK) { FSFW_LOGET("MutexExample::example: Lock Failed with {}\n", result); } diff --git a/example/test/testdefinitions/demoDefinitions.h b/example/test/testdefinitions/demoDefinitions.h index f79fa78..bd35ce0 100644 --- a/example/test/testdefinitions/demoDefinitions.h +++ b/example/test/testdefinitions/demoDefinitions.h @@ -12,21 +12,22 @@ * pool variables (for read and write access respectively). */ class FsfwDemoSet : public StaticLocalDataSet<3> { - public: +public: static constexpr uint32_t DEMO_SET_ID = 0; enum PoolIds { VARIABLE, VARIABLE_LIMIT }; - FsfwDemoSet(HasLocalDataPoolIF* hkOwner) : StaticLocalDataSet(hkOwner, DEMO_SET_ID) {} + FsfwDemoSet(HasLocalDataPoolIF *hkOwner) + : StaticLocalDataSet(hkOwner, DEMO_SET_ID) {} - lp_var_t variableRead = - lp_var_t(sid.objectId, PoolIds::VARIABLE, this, pool_rwm_t::VAR_READ); - lp_var_t variableWrite = - lp_var_t(sid.objectId, PoolIds::VARIABLE, this, pool_rwm_t::VAR_WRITE); + lp_var_t variableRead = lp_var_t( + sid.objectId, PoolIds::VARIABLE, this, pool_rwm_t::VAR_READ); + lp_var_t variableWrite = lp_var_t( + sid.objectId, PoolIds::VARIABLE, this, pool_rwm_t::VAR_WRITE); lp_var_t variableLimit = lp_var_t(sid.objectId, PoolIds::VARIABLE_LIMIT, this); - private: +private: }; /** @@ -35,10 +36,11 @@ class FsfwDemoSet : public StaticLocalDataSet<3> { * which reads multiple sensor values at once. */ class CompleteDemoReadSet : public StaticLocalDataSet<3> { - public: +public: static constexpr uint32_t DEMO_SET_ID = 0; - CompleteDemoReadSet(object_id_t owner, gp_id_t variable1, gp_id_t variable2, gp_id_t variable3) + CompleteDemoReadSet(object_id_t owner, gp_id_t variable1, gp_id_t variable2, + gp_id_t variable3) : StaticLocalDataSet(sid_t(owner, DEMO_SET_ID)), variable1(variable1, this, pool_rwm_t::VAR_READ), variable2(variable2, this, pool_rwm_t::VAR_READ), @@ -48,7 +50,7 @@ class CompleteDemoReadSet : public StaticLocalDataSet<3> { lp_var_t variable2; lp_var_t variable3; - private: +private: }; #endif /* MISSION_DEMO_DEMODEFINITIONS_H_ */ diff --git a/example/utility/CMakeLists.txt b/example/utility/CMakeLists.txt index db2301c..94333d1 100644 --- a/example/utility/CMakeLists.txt +++ b/example/utility/CMakeLists.txt @@ -1,4 +1 @@ -target_sources(${TARGET_NAME} PRIVATE - utility.cpp - TmFunnel.cpp -) +target_sources(${TARGET_NAME} PRIVATE utility.cpp TmFunnel.cpp) diff --git a/example/utility/PusPacketCreator.h b/example/utility/PusPacketCreator.h index 7fa46b7..1aed730 100644 --- a/example/utility/PusPacketCreator.h +++ b/example/utility/PusPacketCreator.h @@ -9,7 +9,7 @@ #define MISSION_UTILITY_PUSPACKETCREATOR_H_ class PusPacketCreator { - public: +public: static void createPusPacketAndPrint(); }; diff --git a/example/utility/TaskCreation.h b/example/utility/TaskCreation.h index 4541f14..9c2e387 100644 --- a/example/utility/TaskCreation.h +++ b/example/utility/TaskCreation.h @@ -10,6 +10,6 @@ void printInitError(const char* objName, object_id_t objectId) { FSFW_LOGW("InitMission: Adding object {} ({:#010x}) failed\n", objName, objectId); } -} // namespace task +} // namespace task #endif /* MISSION_UTILITY_TASKCREATION_H_ */ diff --git a/example/utility/TmFunnel.cpp b/example/utility/TmFunnel.cpp index 3aae433..62ba2a5 100644 --- a/example/utility/TmFunnel.cpp +++ b/example/utility/TmFunnel.cpp @@ -10,8 +10,8 @@ object_id_t TmFunnel::storageDestination = objects::NO_OBJECT; TmFunnel::TmFunnel(object_id_t objectId, uint32_t messageDepth) : SystemObject(objectId), messageDepth(messageDepth) { - tmQueue = QueueFactory::instance()->createMessageQueue(messageDepth, - MessageQueueMessage::MAX_MESSAGE_SIZE); + tmQueue = QueueFactory::instance()->createMessageQueue( + messageDepth, MessageQueueMessage::MAX_MESSAGE_SIZE); storageQueue = QueueFactory::instance()->createMessageQueue( messageDepth, MessageQueueMessage::MAX_MESSAGE_SIZE); } @@ -40,23 +40,25 @@ ReturnValue_t TmFunnel::performOperation(uint8_t operationCode) { } } -ReturnValue_t TmFunnel::handlePacket(TmTcMessage* message) { - uint8_t* packetData = nullptr; +ReturnValue_t TmFunnel::handlePacket(TmTcMessage *message) { + uint8_t *packetData = nullptr; size_t size = 0; - ReturnValue_t result = tmPool->modifyData(message->getStorageId(), &packetData, &size); + ReturnValue_t result = + tmPool->modifyData(message->getStorageId(), &packetData, &size); if (result != HasReturnvaluesIF::RETURN_OK) { return result; } TmPacketPusC packet(packetData); packet.setPacketSequenceCount(this->sourceSequenceCount); sourceSequenceCount++; - sourceSequenceCount = sourceSequenceCount % SpacePacketBase::LIMIT_SEQUENCE_COUNT; + sourceSequenceCount = + sourceSequenceCount % SpacePacketBase::LIMIT_SEQUENCE_COUNT; packet.setErrorControl(); result = tmQueue->sendToDefault(message); if (result != HasReturnvaluesIF::RETURN_OK) { tmPool->deleteData(message->getStorageId()); - FSFW_LOGET("{}", "handlePacket: Error sending to downlink handler\n"); + FSFW_LOGET("handlePacket: Error sending to downlink handler\n"); return result; } @@ -64,7 +66,7 @@ ReturnValue_t TmFunnel::handlePacket(TmTcMessage* message) { result = storageQueue->sendToDefault(message); if (result != HasReturnvaluesIF::RETURN_OK) { tmPool->deleteData(message->getStorageId()); - FSFW_LOGET("{}", "handlePacket: Error sending to storage handler\n"); + FSFW_LOGET("handlePacket: Error sending to storage handler\n"); return result; } } @@ -96,10 +98,11 @@ ReturnValue_t TmFunnel::initialize() { return SystemObject::initialize(); } - AcceptsTelemetryIF* storageTarget = + AcceptsTelemetryIF *storageTarget = ObjectManager::instance()->get(storageDestination); if (storageTarget != nullptr) { - storageQueue->setDefaultDestination(storageTarget->getReportReceptionQueue()); + storageQueue->setDefaultDestination( + storageTarget->getReportReceptionQueue()); } return SystemObject::initialize(); diff --git a/example/utility/TmFunnel.h b/example/utility/TmFunnel.h index 3d066f6..9a7dbce 100644 --- a/example/utility/TmFunnel.h +++ b/example/utility/TmFunnel.h @@ -19,30 +19,33 @@ void setStaticFrameworkObjectIds(); * @ingroup utility * @author J. Meier */ -class TmFunnel : public AcceptsTelemetryIF, public ExecutableObjectIF, public SystemObject { +class TmFunnel : public AcceptsTelemetryIF, + public ExecutableObjectIF, + public SystemObject { friend void(Factory::setStaticFrameworkObjectIds)(); - public: +public: TmFunnel(object_id_t objectId, uint32_t messageDepth = 20); virtual ~TmFunnel(); - virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) override; + virtual MessageQueueId_t + getReportReceptionQueue(uint8_t virtualChannel = 0) override; virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override; virtual ReturnValue_t initialize() override; - protected: +protected: static object_id_t downlinkDestination; static object_id_t storageDestination; - private: +private: uint16_t sourceSequenceCount = 0; - MessageQueueIF* tmQueue = nullptr; - MessageQueueIF* storageQueue = nullptr; + MessageQueueIF *tmQueue = nullptr; + MessageQueueIF *storageQueue = nullptr; - StorageManagerIF* tmPool = nullptr; + StorageManagerIF *tmPool = nullptr; uint32_t messageDepth = 0; - ReturnValue_t handlePacket(TmTcMessage* message); + ReturnValue_t handlePacket(TmTcMessage *message); }; #endif /* MISSION_UTILITY_TMFUNNEL_H_ */ diff --git a/example/utility/compile_time.h b/example/utility/compile_time.h index 0e36724..8d9f9e0 100644 --- a/example/utility/compile_time.h +++ b/example/utility/compile_time.h @@ -13,11 +13,13 @@ * * Assembled by Jean Rabault * - * UNIX_TIMESTAMP gives the UNIX timestamp (unsigned long integer of seconds since 1st Jan 1970) of - * compilation from macros using the compiler defined __TIME__ macro. This should include Gregorian - * calendar leap days, in particular the 29ths of February, 100 and 400 years modulo leaps. + * UNIX_TIMESTAMP gives the UNIX timestamp (unsigned long integer of seconds + * since 1st Jan 1970) of compilation from macros using the compiler defined + * __TIME__ macro. This should include Gregorian calendar leap days, in + * particular the 29ths of February, 100 and 400 years modulo leaps. * - * Careful: __TIME__ is the local time of the computer, NOT the UTC time in general! + * Careful: __TIME__ is the local time of the computer, NOT the UTC time in + * general! * */ @@ -37,19 +39,19 @@ #define CONV_STR2DEC_4(str, i) (CONV_STR2DEC_3(str, i) * 10 + str[i + 3] - '0') // Custom "glue logic" to convert the month name to a usable number -#define GET_MONTH(str, i) \ - (str[i] == 'J' && str[i + 1] == 'a' && str[i + 2] == 'n' ? 1 \ - : str[i] == 'F' && str[i + 1] == 'e' && str[i + 2] == 'b' ? 2 \ - : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'r' ? 3 \ - : str[i] == 'A' && str[i + 1] == 'p' && str[i + 2] == 'r' ? 4 \ - : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'y' ? 5 \ - : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'n' ? 6 \ - : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'l' ? 7 \ - : str[i] == 'A' && str[i + 1] == 'u' && str[i + 2] == 'g' ? 8 \ - : str[i] == 'S' && str[i + 1] == 'e' && str[i + 2] == 'p' ? 9 \ - : str[i] == 'O' && str[i + 1] == 'c' && str[i + 2] == 't' ? 10 \ - : str[i] == 'N' && str[i + 1] == 'o' && str[i + 2] == 'v' ? 11 \ - : str[i] == 'D' && str[i + 1] == 'e' && str[i + 2] == 'c' ? 12 \ +#define GET_MONTH(str, i) \ + (str[i] == 'J' && str[i + 1] == 'a' && str[i + 2] == 'n' ? 1 \ + : str[i] == 'F' && str[i + 1] == 'e' && str[i + 2] == 'b' ? 2 \ + : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'r' ? 3 \ + : str[i] == 'A' && str[i + 1] == 'p' && str[i + 2] == 'r' ? 4 \ + : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'y' ? 5 \ + : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'n' ? 6 \ + : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'l' ? 7 \ + : str[i] == 'A' && str[i + 1] == 'u' && str[i + 2] == 'g' ? 8 \ + : str[i] == 'S' && str[i + 1] == 'e' && str[i + 2] == 'p' ? 9 \ + : str[i] == 'O' && str[i + 1] == 'c' && str[i + 2] == 't' ? 10 \ + : str[i] == 'N' && str[i + 1] == 'o' && str[i + 2] == 'v' ? 11 \ + : str[i] == 'D' && str[i + 1] == 'e' && str[i + 2] == 'c' ? 12 \ : 0) // extract the information from the time string given by __TIME__ and __DATE__ @@ -61,30 +63,37 @@ #define __TIME_YEARS__ CONV_STR2DEC_4(__DATE__, 7) // Days in February -#define _UNIX_TIMESTAMP_FDAY(year) \ - (((year) % 400) == 0UL ? 29UL \ - : (((year) % 100) == 0UL ? 28UL : (((year) % 4) == 0UL ? 29UL : 28UL))) +#define _UNIX_TIMESTAMP_FDAY(year) \ + (((year) % 400) == 0UL \ + ? 29UL \ + : (((year) % 100) == 0UL ? 28UL : (((year) % 4) == 0UL ? 29UL : 28UL))) // Days in the year -#define _UNIX_TIMESTAMP_YDAY(year, month, day) \ - (/* January */ day /* February */ + (month >= 2 ? 31UL : 0UL) /* March */ + \ - (month >= 3 ? _UNIX_TIMESTAMP_FDAY(year) : 0UL) /* April */ + \ - (month >= 4 ? 31UL : 0UL) /* May */ + (month >= 5 ? 30UL : 0UL) /* June */ + \ - (month >= 6 ? 31UL : 0UL) /* July */ + (month >= 7 ? 30UL : 0UL) /* August */ + \ - (month >= 8 ? 31UL : 0UL) /* September */ + (month >= 9 ? 31UL : 0UL) /* October */ + \ - (month >= 10 ? 30UL : 0UL) /* November */ + (month >= 11 ? 31UL : 0UL) /* December */ + \ - (month >= 12 ? 30UL : 0UL)) +#define _UNIX_TIMESTAMP_YDAY(year, month, day) \ + (/* January */ day /* February */ + (month >= 2 ? 31UL : 0UL) /* March */ + \ + (month >= 3 ? _UNIX_TIMESTAMP_FDAY(year) : 0UL) /* April */ + \ + (month >= 4 ? 31UL : 0UL) /* May */ + \ + (month >= 5 ? 30UL : 0UL) /* June */ + \ + (month >= 6 ? 31UL : 0UL) /* July */ + \ + (month >= 7 ? 30UL : 0UL) /* August */ + \ + (month >= 8 ? 31UL : 0UL) /* September */ + \ + (month >= 9 ? 31UL : 0UL) /* October */ + \ + (month >= 10 ? 30UL : 0UL) /* November */ + \ + (month >= 11 ? 31UL : 0UL) /* December */ + (month >= 12 ? 30UL : 0UL)) // get the UNIX timestamp from a digits representation -#define _UNIX_TIMESTAMP(year, month, day, hour, minute, second) \ - (/* time */ second + minute * SEC_PER_MIN + hour * SEC_PER_HOUR + \ - /* year day (month + day) */ (_UNIX_TIMESTAMP_YDAY(year, month, day) - 1) * SEC_PER_DAY + \ - /* year */ (year - 1970UL) * SEC_PER_YEAR + ((year - 1969UL) / 4UL) * SEC_PER_DAY - \ - ((year - 1901UL) / 100UL) * SEC_PER_DAY + ((year - 1601UL) / 400UL) * SEC_PER_DAY) +#define _UNIX_TIMESTAMP(year, month, day, hour, minute, second) \ + (/* time */ second + minute * SEC_PER_MIN + hour * SEC_PER_HOUR + \ + /* year day (month + day) */ (_UNIX_TIMESTAMP_YDAY(year, month, day) - 1) * \ + SEC_PER_DAY + \ + /* year */ (year - 1970UL) * SEC_PER_YEAR + \ + ((year - 1969UL) / 4UL) * SEC_PER_DAY - \ + ((year - 1901UL) / 100UL) * SEC_PER_DAY + \ + ((year - 1601UL) / 400UL) * SEC_PER_DAY) // the UNIX timestamp -#define UNIX_TIMESTAMP \ - (_UNIX_TIMESTAMP(__TIME_YEARS__, __TIME_MONTH__, __TIME_DAYS__, __TIME_HOURS__, \ - __TIME_MINUTES__, __TIME_SECONDS__)) +#define UNIX_TIMESTAMP \ + (_UNIX_TIMESTAMP(__TIME_YEARS__, __TIME_MONTH__, __TIME_DAYS__, \ + __TIME_HOURS__, __TIME_MINUTES__, __TIME_SECONDS__)) #endif diff --git a/example/utility/utility.cpp b/example/utility/utility.cpp index e75be62..8750d8d 100644 --- a/example/utility/utility.cpp +++ b/example/utility/utility.cpp @@ -4,13 +4,29 @@ #include "fsfw/serviceinterface.h" -void utility::commonInitPrint(const char* const os, const char* const board) { +void utility::commonInitPrint(const char *const os, const char *const board) { if (os == nullptr or board == nullptr) { return; } +<<<<<<< HEAD fmt::print("-- FSFW Example ({}) v{}.{}.{} --\n", os, FSFW_EXAMPLE_VERSION, FSFW_EXAMPLE_SUBVERSION, FSFW_EXAMPLE_REVISION); fmt::print("-- Compiled for {}\n", board); fmt::print("-- Compiled on {} {}\n", __DATE__, __TIME__); sif::initialize(); +======= +#if FSFW_CPP_OSTREAM_ENABLED == 1 + std::cout << "-- FSFW Example (" << os << ") v" << FSFW_EXAMPLE_VERSION << "." + << FSFW_EXAMPLE_SUBVERSION << "." << FSFW_EXAMPLE_REVISION << " --" + << std::endl; + std::cout << "-- Compiled for " << board << " --" << std::endl; + std::cout << "-- Compiled on " << __DATE__ << " " << __TIME__ << " --" + << std::endl; +#else + printf("\n\r-- FSFW Example (%s) v%d.%d.%d --\n", os, FSFW_EXAMPLE_VERSION, + FSFW_EXAMPLE_SUBVERSION, FSFW_EXAMPLE_REVISION); + printf("-- Compiled for %s --\n", board); + printf("-- Compiled on %s %s --\n", __DATE__, __TIME__); +#endif +>>>>>>> origin/master } diff --git a/example/utility/utility.h b/example/utility/utility.h index 4f1683a..9aeb2ec 100644 --- a/example/utility/utility.h +++ b/example/utility/utility.h @@ -3,7 +3,7 @@ namespace utility { -void commonInitPrint(const char* const os, const char* const board); +void commonInitPrint(const char *const os, const char *const board); } diff --git a/scripts/auto-formatter.sh b/scripts/auto-formatter.sh new file mode 100755 index 0000000..1cbdb9a --- /dev/null +++ b/scripts/auto-formatter.sh @@ -0,0 +1,44 @@ +#!/bin/bash +counter=0 +common_example_dir="example_common" +while [ ${counter} -lt 5 ] +do + if [ ! -d ${common_example_dir} ];then + break + fi + counter=$((counter=counter + 1)) + cd .. +done + +if [ "${counter}" -ge 5 ];then + echo "${common_example_dir} not found in upper directories!" + exit 1 +fi + +folder_list=( + "./bsp_hosted" + "./example_common" +) + +cmake_fmt="cmake-format" +file_selectors="-iname CMakeLists.txt" +if command -v ${cmake_fmt} &> /dev/null; then + echo "Auto-formatting all CMakeLists.txt files" + ${cmake_fmt} -i CMakeLists.txt + for dir in ${folder_list[@]}; do + find ${dir} ${file_selectors} | xargs ${cmake_fmt} -i + done +else + echo "No ${cmake_fmt} tool found, not formatting CMake files" +fi + +cpp_format="clang-format" +file_selectors="-iname *.h -o -iname *.cpp -o -iname *.c -o -iname *.tpp" +if command -v ${cpp_format} &> /dev/null; then + for dir in ${folder_list[@]}; do + echo "Auto-formatting C/C++ files in ${dir} recursively" + find ${dir} ${file_selectors} | xargs ${cpp_format} --style=file -i + done +else + echo "No ${cpp_format} tool found, not formatting C++/C files" +fi diff --git a/stm32h7/CMakeLists.txt b/stm32h7/CMakeLists.txt index 3ae2e12..cd9d542 100644 --- a/stm32h7/CMakeLists.txt +++ b/stm32h7/CMakeLists.txt @@ -1,9 +1,7 @@ -target_sources(${TARGET_NAME} PRIVATE - STM32TestTask.cpp -) +target_sources(${TARGET_NAME} PRIVATE STM32TestTask.cpp) option(STM32_ADD_NETWORKING_CODE "Add networking code requiring lwIP" ON) if(STM32_ADD_NETWORKING_CODE) - add_subdirectory(networking) -endif() \ No newline at end of file + add_subdirectory(networking) +endif() diff --git a/stm32h7/STM32TestTask.cpp b/stm32h7/STM32TestTask.cpp index c34ccf9..c41810e 100644 --- a/stm32h7/STM32TestTask.cpp +++ b/stm32h7/STM32TestTask.cpp @@ -3,16 +3,25 @@ #include "OBSWConfig.h" #include "stm32h7xx_nucleo.h" -STM32TestTask::STM32TestTask(object_id_t objectId, bool enablePrintout, bool blinkyLed) +STM32TestTask::STM32TestTask(object_id_t objectId, bool enablePrintout, + bool blinkyLed) : TestTask(objectId), blinkyLed(blinkyLed) { BSP_LED_Init(LED1); BSP_LED_Init(LED2); BSP_LED_Init(LED3); } +ReturnValue_t STM32TestTask::initialize() { + if (testSpi) { + spiComIF = new SpiComIF(objects::SPI_COM_IF); + spiTest = new SpiTest(*spiComIF); + } + return TestTask::initialize(); +} + ReturnValue_t STM32TestTask::performPeriodicAction() { if (blinkyLed) { -#if OBSW_ETHERNET_USE_LEDS == 0 +#if OBSW_ETHERNET_USE_LED1_LED2 == 0 BSP_LED_Toggle(LED1); BSP_LED_Toggle(LED2); #endif @@ -23,11 +32,3 @@ ReturnValue_t STM32TestTask::performPeriodicAction() { } return TestTask::performPeriodicAction(); } - -ReturnValue_t STM32TestTask::initialize() { - if (testSpi) { - spiComIF = new SpiComIF(objects::SPI_COM_IF); - spiTest = new SpiTest(*spiComIF); - } - return TestTask::initialize(); -} diff --git a/stm32h7/STM32TestTask.h b/stm32h7/STM32TestTask.h index 0f75d71..4cb2a72 100644 --- a/stm32h7/STM32TestTask.h +++ b/stm32h7/STM32TestTask.h @@ -5,18 +5,19 @@ #include "fsfw_tests/integration/task/TestTask.h" class STM32TestTask : public TestTask { - public: - STM32TestTask(object_id_t objectId, bool enablePrintout, bool blinkyLed = true); +public: + STM32TestTask(object_id_t objectId, bool enablePrintout, + bool blinkyLed = true); ReturnValue_t initialize() override; ReturnValue_t performPeriodicAction() override; - private: - SpiComIF* spiComIF = nullptr; - SpiTest* spiTest = nullptr; +private: + SpiComIF *spiComIF = nullptr; + SpiTest *spiTest = nullptr; bool blinkyLed = false; - bool testSpi = true; + bool testSpi = false; }; #endif /* BSP_STM32_BOARDTEST_STM32TESTTASK_H_ */ diff --git a/stm32h7/networking/CMakeLists.txt b/stm32h7/networking/CMakeLists.txt index 9e61958..68e56e6 100644 --- a/stm32h7/networking/CMakeLists.txt +++ b/stm32h7/networking/CMakeLists.txt @@ -1,14 +1,8 @@ # These are part of the RTEMS BSP for RTEMS if(FSFW_OSAL MATCHES freertos) - target_sources(${TARGET_NAME} PRIVATE - ethernetif.c - ) + target_sources(${TARGET_NAME} PRIVATE ethernetif.c) endif() -target_sources(${TARGET_NAME} PRIVATE - UdpTcLwIpPollingTask.cpp - TmTcLwIpUdpBridge.cpp - networking.cpp - app_dhcp.cpp - app_ethernet.cpp -) +target_sources( + ${TARGET_NAME} PRIVATE UdpTcLwIpPollingTask.cpp TmTcLwIpUdpBridge.cpp + networking.cpp app_dhcp.cpp app_ethernet.cpp) diff --git a/stm32h7/networking/TmTcLwIpUdpBridge.cpp b/stm32h7/networking/TmTcLwIpUdpBridge.cpp index cd580a6..8f66606 100644 --- a/stm32h7/networking/TmTcLwIpUdpBridge.cpp +++ b/stm32h7/networking/TmTcLwIpUdpBridge.cpp @@ -1,21 +1,22 @@ #include "TmTcLwIpUdpBridge.h" -#include + #include #include #include #include "app_ethernet.h" -#include "ethernetif.h" #include "udp_config.h" -TmTcLwIpUdpBridge::TmTcLwIpUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor, - object_id_t tmStoreId, object_id_t tcStoreId) +TmTcLwIpUdpBridge::TmTcLwIpUdpBridge(object_id_t objectId, + object_id_t ccsdsPacketDistributor, + object_id_t tmStoreId, + object_id_t tcStoreId) : TmTcBridge(objectId, ccsdsPacketDistributor, tmStoreId, tcStoreId) { TmTcLwIpUdpBridge::lastAdd.addr = IPADDR_TYPE_ANY; } -TmTcLwIpUdpBridge::~TmTcLwIpUdpBridge() {} +TmTcLwIpUdpBridge::~TmTcLwIpUdpBridge() = default; ReturnValue_t TmTcLwIpUdpBridge::initialize() { TmTcBridge::initialize(); @@ -27,18 +28,20 @@ ReturnValue_t TmTcLwIpUdpBridge::initialize() { return result; } -ReturnValue_t TmTcLwIpUdpBridge::udp_server_init(void) { +ReturnValue_t TmTcLwIpUdpBridge::udp_server_init() { err_t err; /* Create a new UDP control block */ TmTcLwIpUdpBridge::upcb = udp_new(); if (TmTcLwIpUdpBridge::upcb) { + sif::printInfo("Opening UDP server on port %d\n", UDP_SERVER_PORT); /* Bind the upcb to the UDP_PORT port */ /* Using IP_ADDR_ANY allow the upcb to be used by any local interface */ err = udp_bind(TmTcLwIpUdpBridge::upcb, IP_ADDR_ANY, UDP_SERVER_PORT); if (err == ERR_OK) { /* Set a receive callback for the upcb */ - udp_recv(TmTcLwIpUdpBridge::upcb, &udp_server_receive_callback, (void*)this); + udp_recv(TmTcLwIpUdpBridge::upcb, &udp_server_receive_callback, + (void *)this); return RETURN_OK; } else { udp_remove(TmTcLwIpUdpBridge::upcb); @@ -52,22 +55,24 @@ ReturnValue_t TmTcLwIpUdpBridge::udp_server_init(void) { ReturnValue_t TmTcLwIpUdpBridge::performOperation(uint8_t operationCode) { TmTcBridge::performOperation(); -#if TCPIP_RECV_WIRETAPPING == 1 +#if OBSW_TCPIP_UDP_WIRETAPPING == 1 if (connectFlag) { - uint32_t ipAddress = ((ip4_addr*)&lastAdd)->addr; + uint32_t ipAddress = ((ip4_addr *)&lastAdd)->addr; int ipAddress1 = (ipAddress & 0xFF000000) >> 24; int ipAddress2 = (ipAddress & 0xFF0000) >> 16; int ipAddress3 = (ipAddress & 0xFF00) >> 8; int ipAddress4 = ipAddress & 0xFF; #if OBSW_VERBOSE_LEVEL == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1 - sif::info << "TmTcLwIpUdpBridge: Client IP Address " << std::dec << ipAddress4 << "." - << ipAddress3 << "." << ipAddress2 << "." << ipAddress1 << std::endl; + sif::info << "TmTcLwIpUdpBridge: Client IP Address " << std::dec + << ipAddress4 << "." << ipAddress3 << "." << ipAddress2 << "." + << ipAddress1 << std::endl; uint16_t portSwapped = EndianConverter::convertBigEndian(lastPort); - sif::info << "TmTcLwIpUdpBridge: Client IP Port " << (int)portSwapped << std::endl; + sif::info << "TmTcLwIpUdpBridge: Client IP Port " << (int)portSwapped + << std::endl; #else - sif::printInfo("TmTcLwIpUdpBridge: Client IP Address %d.%d.%d.%d\n", ipAddress4, ipAddress3, - ipAddress2, ipAddress1); + sif::printInfo("TmTcLwIpUdpBridge: Client IP Address %d.%d.%d.%d\n", + ipAddress4, ipAddress3, ipAddress2, ipAddress1); uint16_t portSwapped = EndianConverter::convertBigEndian(lastPort); sif::printInfo("TmTcLwIpUdpBridge: Client IP Port: %d\n", portSwapped); #endif @@ -79,11 +84,12 @@ ReturnValue_t TmTcLwIpUdpBridge::performOperation(uint8_t operationCode) { return RETURN_OK; } -ReturnValue_t TmTcLwIpUdpBridge::sendTm(const uint8_t* data, size_t dataLen) { - struct pbuf* p_tx = pbuf_alloc(PBUF_TRANSPORT, dataLen, PBUF_RAM); - if ((p_tx != nullptr) && (lastAdd.addr != IPADDR_TYPE_ANY) && (upcb != nullptr)) { +ReturnValue_t TmTcLwIpUdpBridge::sendTm(const uint8_t *data, size_t dataLen) { + struct pbuf *p_tx = pbuf_alloc(PBUF_TRANSPORT, dataLen, PBUF_RAM); + if ((p_tx != nullptr) && (lastAdd.addr != IPADDR_TYPE_ANY) && + (upcb != nullptr)) { /* copy data to pbuf */ - err_t err = pbuf_take(p_tx, (char*)data, dataLen); + err_t err = pbuf_take(p_tx, (const char *)data, dataLen); if (err != ERR_OK) { pbuf_free(p_tx); return err; @@ -109,23 +115,26 @@ ReturnValue_t TmTcLwIpUdpBridge::sendTm(const uint8_t* data, size_t dataLen) { return RETURN_OK; } -void TmTcLwIpUdpBridge::udp_server_receive_callback(void* arg, struct udp_pcb* upcb_, - struct pbuf* p, const ip_addr_t* addr, +void TmTcLwIpUdpBridge::udp_server_receive_callback(void *arg, + struct udp_pcb *upcb_, + struct pbuf *p, + const ip_addr_t *addr, u16_t port) { - struct pbuf* p_tx = nullptr; - auto udpBridge = reinterpret_cast(arg); + auto udpBridge = reinterpret_cast(arg); if (udpBridge == nullptr) { #if FSFW_CPP_OSTREAM_ENABLED == 1 - sif::warning << "TmTcLwIpUdpBridge::udp_server_receive_callback: Invalid UDP bridge!" - << std::endl; + sif::warning + << "TmTcLwIpUdpBridge::udp_server_receive_callback: Invalid UDP bridge!" + << std::endl; #else - sif::printWarning("TmTcLwIpUdpBridge::udp_server_receive_callback: Invalid UDP bridge!\n"); + sif::printWarning("TmTcLwIpUdpBridge::udp_server_receive_callback: Invalid " + "UDP bridge!\n"); #endif } /* allocate pbuf from RAM*/ - p_tx = pbuf_alloc(PBUF_TRANSPORT, p->len, PBUF_RAM); + struct pbuf *p_tx = pbuf_alloc(PBUF_TRANSPORT, p->len, PBUF_RAM); - if (p_tx != NULL) { + if (p_tx != nullptr) { if (udpBridge != nullptr) { MutexGuard lg(udpBridge->bridgeLock); udpBridge->upcb = upcb_; @@ -133,25 +142,25 @@ void TmTcLwIpUdpBridge::udp_server_receive_callback(void* arg, struct udp_pcb* u udpBridge->lastPort = port; if (not udpBridge->comLinkUp()) { udpBridge->registerCommConnect(); -#if TCPIP_RECV_WIRETAPPING == 1 +#if OBSW_TCPIP_UDP_WIRETAPPING == 1 udpBridge->connectFlag = true; #endif /* This should have already been done, but we will still do it */ udpBridge->physicalConnectStatusChange(true); } } - pbuf_take(p_tx, (char*)p->payload, p->len); + pbuf_take(p_tx, (char *)p->payload, p->len); /* send the received data to the uart port */ - char* data = reinterpret_cast(p_tx->payload); + char *data = reinterpret_cast(p_tx->payload); *(data + p_tx->len) = '\0'; -#if TCPIP_RECV_WIRETAPPING == 1 - udpBridge->printData(p, data); +#if OBSW_TCPIP_UDP_WIRETAPPING == 1 + udpBridge->printData(reinterpret_cast(p->payload), p->len); #endif store_address_t storeId; - ReturnValue_t returnValue = - udpBridge->tcStore->addData(&storeId, reinterpret_cast(p->payload), p->len); + ReturnValue_t returnValue = udpBridge->tcStore->addData( + &storeId, reinterpret_cast(p->payload), p->len); if (returnValue != RETURN_OK) { #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "UDP Server: Data storage failed" << std::endl; @@ -178,8 +187,8 @@ bool TmTcLwIpUdpBridge::comLinkUp() const { return communicationLinkUp; } /* Caller must ensure thread-safety */ void TmTcLwIpUdpBridge::physicalConnectStatusChange(bool connect) { if (connect) { - /* Physical connection does not mean there is a recipient to send packets too. - This will be done by the receive callback! */ + /* Physical connection does not mean there is a recipient to send packets + too. This will be done by the receive callback! */ physicalConnection = true; } else { physicalConnection = false; diff --git a/stm32h7/networking/TmTcLwIpUdpBridge.h b/stm32h7/networking/TmTcLwIpUdpBridge.h index 0138e09..61e80cc 100644 --- a/stm32h7/networking/TmTcLwIpUdpBridge.h +++ b/stm32h7/networking/TmTcLwIpUdpBridge.h @@ -1,24 +1,25 @@ #ifndef BSP_STM32_RTEMS_NETWORKING_TMTCUDPBRIDGE_H_ #define BSP_STM32_RTEMS_NETWORKING_TMTCUDPBRIDGE_H_ -#include +#include "fsfw/tmtcservices/TmTcBridge.h" +#include "commonConfig.h" + #include #include -#define TCPIP_RECV_WIRETAPPING 0 - /** - * This bridge is used to forward TMTC packets received via LwIP UDP to the internal software bus. + * This bridge is used to forward TMTC packets received via LwIP UDP to the + * internal software bus. */ class TmTcLwIpUdpBridge : public TmTcBridge { friend class UdpTcLwIpPollingTask; - public: - TmTcLwIpUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor, object_id_t tmStoreId, - object_id_t tcStoreId); - virtual ~TmTcLwIpUdpBridge(); +public: + TmTcLwIpUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor, + object_id_t tmStoreId, object_id_t tcStoreId); + ~TmTcLwIpUdpBridge() override; - virtual ReturnValue_t initialize() override; + ReturnValue_t initialize() override; ReturnValue_t udp_server_init(); /** @@ -26,14 +27,14 @@ class TmTcLwIpUdpBridge : public TmTcBridge { * @param operationCode * @return */ - virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override; + ReturnValue_t performOperation(uint8_t operationCode) override; /** TM Send implementation uses udp_send function from lwIP stack * @param data * @param dataLen * @return */ - virtual ReturnValue_t sendTm(const uint8_t *data, size_t dataLen) override; + ReturnValue_t sendTm(const uint8_t *data, size_t dataLen) override; /** * @brief This function is called when an UDP datagram has been @@ -44,32 +45,33 @@ class TmTcLwIpUdpBridge : public TmTcBridge { * @param addr Source address which will be bound to TmTcUdpBridge::lastAdd * @param port */ - static void udp_server_receive_callback(void *arg, struct udp_pcb *upcb_, struct pbuf *p, - const ip_addr_t *addr, u16_t port); + static void udp_server_receive_callback(void *arg, struct udp_pcb *upcb_, + struct pbuf *p, const ip_addr_t *addr, + u16_t port); /** * Check whether the communication link is up. * Caller must ensure thread-safety by using the bridge lock. * @return */ - bool comLinkUp() const; + [[nodiscard]] bool comLinkUp() const; - private: +private: struct udp_pcb *upcb = nullptr; - ip_addr_t lastAdd; + ip_addr_t lastAdd{}; u16_t lastPort = 0; bool physicalConnection = false; MutexIF *bridgeLock = nullptr; -#if TCPIP_RECV_WIRETAPPING == 1 +#if OBSW_TCPIP_UDP_WIRETAPPING == 1 bool connectFlag = false; #endif /** * Used to notify bridge about change in the physical ethernet connection. - * Connection does not mean that replies are possible (recipient not set yet), but - * disconnect means that we can't send anything. Caller must ensure thread-safety - * by using the bridge lock. + * Connection does not mean that replies are possible (recipient not set yet), + * but disconnect means that we can't send anything. Caller must ensure + * thread-safety by using the bridge lock. */ void physicalConnectStatusChange(bool connect); }; diff --git a/stm32h7/networking/UdpTcLwIpPollingTask.cpp b/stm32h7/networking/UdpTcLwIpPollingTask.cpp index aeb70e0..9b426f8 100644 --- a/stm32h7/networking/UdpTcLwIpPollingTask.cpp +++ b/stm32h7/networking/UdpTcLwIpPollingTask.cpp @@ -1,7 +1,5 @@ #include "UdpTcLwIpPollingTask.h" -#include - #include "TmTcLwIpUdpBridge.h" #include "app_dhcp.h" #include "app_ethernet.h" @@ -12,11 +10,13 @@ #include "lwip/timeouts.h" #include "networking.h" -UdpTcLwIpPollingTask::UdpTcLwIpPollingTask(object_id_t objectId, object_id_t bridgeId, - struct netif* gnetif) - : SystemObject(objectId), periodicHandleCounter(0), bridgeId(bridgeId), gnetif(gnetif) {} +UdpTcLwIpPollingTask::UdpTcLwIpPollingTask(object_id_t objectId, + object_id_t bridgeId, + struct netif *gnetif) + : SystemObject(objectId), periodicHandleCounter(0), bridgeId(bridgeId), + gnetif(gnetif) {} -UdpTcLwIpPollingTask::~UdpTcLwIpPollingTask() {} +UdpTcLwIpPollingTask::~UdpTcLwIpPollingTask() = default; ReturnValue_t UdpTcLwIpPollingTask::initialize() { udpBridge = ObjectManager::instance()->get(bridgeId); @@ -47,7 +47,8 @@ ReturnValue_t UdpTcLwIpPollingTask::performOperation(uint8_t operationCode) { /* In case ethernet cable is disconnected */ if (not networking::getEthCableConnected() and udpBridge->comLinkUp()) { udpBridge->physicalConnectStatusChange(false); - } else if (networking::getEthCableConnected() and not udpBridge->comLinkUp()) { + } else if (networking::getEthCableConnected() and + not udpBridge->comLinkUp()) { udpBridge->physicalConnectStatusChange(true); } } diff --git a/stm32h7/networking/UdpTcLwIpPollingTask.h b/stm32h7/networking/UdpTcLwIpPollingTask.h index d9c72c3..40f688e 100644 --- a/stm32h7/networking/UdpTcLwIpPollingTask.h +++ b/stm32h7/networking/UdpTcLwIpPollingTask.h @@ -1,5 +1,4 @@ -#ifndef BSP_STM32_RTEMS_EMACPOLLINGTASK_H_ -#define BSP_STM32_RTEMS_EMACPOLLINGTASK_H_ +#pragma once #include #include @@ -15,25 +14,24 @@ class TmTcLwIpUdpBridge; class UdpTcLwIpPollingTask : public SystemObject, public ExecutableObjectIF, public HasReturnvaluesIF { - public: - UdpTcLwIpPollingTask(object_id_t objectId, object_id_t bridgeId, struct netif* gnetif); - virtual ~UdpTcLwIpPollingTask(); +public: + UdpTcLwIpPollingTask(object_id_t objectId, object_id_t bridgeId, + struct netif *gnetif); + ~UdpTcLwIpPollingTask() override; - virtual ReturnValue_t initialize() override; + ReturnValue_t initialize() override; /** * Executed periodically. * @param operationCode * @return */ - virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override; + ReturnValue_t performOperation(uint8_t operationCode) override; - private: +private: static const uint8_t PERIODIC_HANDLE_TRIGGER = 5; uint8_t periodicHandleCounter; object_id_t bridgeId = 0; - TmTcLwIpUdpBridge* udpBridge = nullptr; - struct netif* gnetif = nullptr; + TmTcLwIpUdpBridge *udpBridge = nullptr; + struct netif *gnetif = nullptr; }; - -#endif /* BSP_STM32_RTEMS_EMACPOLLINGTASK_H_ */ diff --git a/stm32h7/networking/app_dhcp.cpp b/stm32h7/networking/app_dhcp.cpp index 8d20bed..6f53c7c 100644 --- a/stm32h7/networking/app_dhcp.cpp +++ b/stm32h7/networking/app_dhcp.cpp @@ -1,8 +1,6 @@ #include "app_dhcp.h" #include "OBSWConfig.h" -#include "app_ethernet.h" -#include "ethernetif.h" #include "lwip/dhcp.h" #include "networking.h" #include "stm32h7xx_nucleo.h" @@ -13,39 +11,39 @@ uint8_t DHCP_state = DHCP_OFF; uint32_t DHCPfineTimer = 0; -void handle_dhcp_timeout(struct netif* netif); -void handle_dhcp_start(struct netif* netif); -void handle_dhcp_wait(struct netif* netif, struct dhcp** dhcp); -void handle_dhcp_down(struct netif* netif); +void handle_dhcp_timeout(struct netif *netif); +void handle_dhcp_start(struct netif *netif); +void handle_dhcp_wait(struct netif *netif, struct dhcp **dhcp); +void handle_dhcp_down(struct netif *netif); /** * @brief DHCP_Process_Handle * @param None * @retval None */ -void DHCP_Process(struct netif* netif) { - struct dhcp* dhcp = NULL; +void DHCP_Process(struct netif *netif) { + struct dhcp *dhcp = nullptr; switch (DHCP_state) { - case DHCP_START: { - handle_dhcp_start(netif); - break; - } - case DHCP_WAIT_ADDRESS: { - handle_dhcp_wait(netif, &dhcp); - break; - } + case DHCP_START: { + handle_dhcp_start(netif); + break; + } + case DHCP_WAIT_ADDRESS: { + handle_dhcp_wait(netif, &dhcp); + break; + } - case DHCP_LINK_DOWN: { - handle_dhcp_down(netif); - break; - } - default: { - break; - } + case DHCP_LINK_DOWN: { + handle_dhcp_down(netif); + break; + } + default: { + break; + } } } -void handle_dhcp_timeout(struct netif* netif) { +void handle_dhcp_timeout(struct netif *netif) { ip_addr_t ipaddr; ip_addr_t netmask; ip_addr_t gw; @@ -61,11 +59,11 @@ void handle_dhcp_timeout(struct netif* netif) { printf("DHCP Timeout\n\r"); uint8_t iptxt[20]; - sprintf((char*)iptxt, "%s", ip4addr_ntoa(netif_ip4_addr(netif))); + sprintf((char *)iptxt, "%s", ip4addr_ntoa(netif_ip4_addr(netif))); printf("Assigning static IP address: %s\n", iptxt); #if defined FSFW_OSAL_FREERTOS - ETH_HandleTypeDef* handle = getEthernetHandle(); + ETH_HandleTypeDef *handle = getEthernetHandle(); handle->gState = HAL_ETH_STATE_READY; #endif @@ -82,7 +80,7 @@ void handle_dhcp_timeout(struct netif* netif) { * @param netif * @retval None */ -void DHCP_Periodic_Handle(struct netif* netif) { +void DHCP_Periodic_Handle(struct netif *netif) { /* Fine DHCP periodic process every 500ms */ if (HAL_GetTick() - DHCPfineTimer >= DHCP_FINE_TIMER_MSECS) { DHCPfineTimer = HAL_GetTick(); @@ -91,7 +89,7 @@ void DHCP_Periodic_Handle(struct netif* netif) { } } -void handle_dhcp_start(struct netif* netif) { +void handle_dhcp_start(struct netif *netif) { printf("handle_dhcp_start: Looking for DHCP server ...\n\r"); #if OBSW_ETHERNET_TMTC_COMMANDING == 1 #if OBSW_ETHERNET_USE_LED1_LED2 == 1 @@ -106,10 +104,11 @@ void handle_dhcp_start(struct netif* netif) { DHCP_state = DHCP_WAIT_ADDRESS; } -void handle_dhcp_wait(struct netif* netif, struct dhcp** dhcp) { +void handle_dhcp_wait(struct netif *netif, struct dhcp **dhcp) { if (dhcp_supplied_address(netif)) { DHCP_state = DHCP_ADDRESS_ASSIGNED; - printf("IP address assigned by a DHCP server: %s\n\r", ip4addr_ntoa(netif_ip4_addr(netif))); + printf("IP address assigned by a DHCP server: %s\n\r", + ip4addr_ntoa(netif_ip4_addr(netif))); printf("Listener port: %d\n\r", UDP_SERVER_PORT); #if OBSW_ETHERNET_TMTC_COMMANDING == 1 #if OBSW_ETHERNET_USE_LED1_LED2 == 1 @@ -118,7 +117,8 @@ void handle_dhcp_wait(struct netif* netif, struct dhcp** dhcp) { #endif #endif } else { - *dhcp = (struct dhcp*)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP); + *dhcp = static_cast(netif_get_client_data( + netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP)); /* DHCP timeout */ if ((*dhcp)->tries > MAX_DHCP_TRIES) { @@ -127,7 +127,8 @@ void handle_dhcp_wait(struct netif* netif, struct dhcp** dhcp) { } } -void handle_dhcp_down(struct netif* netif) { +void handle_dhcp_down(struct netif *netif) { + static_cast(netif); DHCP_state = DHCP_OFF; #if OBSW_ETHERNET_TMTC_COMMANDING == 1 printf("DHCP_Process: The network cable is not connected.\n\r"); diff --git a/stm32h7/networking/app_ethernet.cpp b/stm32h7/networking/app_ethernet.cpp index 068a029..5edc1ad 100644 --- a/stm32h7/networking/app_ethernet.cpp +++ b/stm32h7/networking/app_ethernet.cpp @@ -21,7 +21,7 @@ uint32_t ethernetLinkTimer = 0; /* Private function prototypes -----------------------------------------------*/ -void handle_status_change(struct netif* netif, bool link_up); +void handle_status_change(struct netif *netif, bool link_up); /* Private functions ---------------------------------------------------------*/ /** @@ -29,7 +29,7 @@ void handle_status_change(struct netif* netif, bool link_up); * @param netif: the network interface * @retval None */ -void networking::ethernetLinkStatusUpdated(struct netif* netif) { +void networking::ethernetLinkStatusUpdated(struct netif *netif) { if (netif_is_link_up(netif)) { networking::setEthCableConnected(true); handle_status_change(netif, true); @@ -39,16 +39,16 @@ void networking::ethernetLinkStatusUpdated(struct netif* netif) { } } -void handle_status_change(struct netif* netif, bool link_up) { +void handle_status_change(struct netif *netif, bool link_up) { if (link_up) { #if LWIP_DHCP /* Update DHCP state machine */ set_dhcp_state(DHCP_START); #else uint8_t iptxt[20]; - sprintf((char*)iptxt, "%s", ip4addr_ntoa(netif_ip4_addr(netif))); - printf("\rNetwork cable connected. Static IP address: %s | Port: %d\n\r", iptxt, - UDP_SERVER_PORT); + sprintf((char *)iptxt, "%s", ip4addr_ntoa(netif_ip4_addr(netif))); + printf("\rNetwork cable connected. Static IP address: %s | Port: %d\n\r", + iptxt, UDP_SERVER_PORT); #if OBSW_ETHERNET_USE_LED1_LED2 == 1 BSP_LED_On(LED1); BSP_LED_Off(LED2); @@ -75,7 +75,7 @@ void handle_status_change(struct netif* netif, bool link_up) { * @param netif * @retval None */ -void networking::ethernetLinkPeriodicHandle(struct netif* netif) { +void networking::ethernetLinkPeriodicHandle(struct netif *netif) { /* Ethernet Link every 100ms */ if (HAL_GetTick() - ethernetLinkTimer >= 100) { ethernetLinkTimer = HAL_GetTick(); diff --git a/stm32h7/networking/app_ethernet.h b/stm32h7/networking/app_ethernet.h index 4662ff3..2867659 100644 --- a/stm32h7/networking/app_ethernet.h +++ b/stm32h7/networking/app_ethernet.h @@ -65,7 +65,7 @@ namespace networking { void ethernetLinkStatusUpdated(struct netif *netif); void ethernetLinkPeriodicHandle(struct netif *netif); -} // namespace networking +} // namespace networking #ifdef __cplusplus } diff --git a/stm32h7/networking/ethernetif.c b/stm32h7/networking/ethernetif.c index 8cc50b8..38f21dc 100644 --- a/stm32h7/networking/ethernetif.c +++ b/stm32h7/networking/ethernetif.c @@ -44,16 +44,16 @@ */ /* Includes ------------------------------------------------------------------*/ +#include "stm32h7xx_hal.h" +#include "lwip/opt.h" +#include "lwip/timeouts.h" +#include "lwip/netif.h" +#include "netif/etharp.h" #include "ethernetif.h" - -#include -#include -#include -#include -#include -#include +#include "lan8742.h" #include +#include #include "fsfw/FSFW.h" #ifdef FSFW_OSAL_RTEMS @@ -66,14 +66,20 @@ #define IFNAME0 's' #define IFNAME1 't' +#define ETH_DMA_TRANSMIT_TIMEOUT (20U) + +#define ETH_RX_BUFFER_SIZE 1536U +#define ETH_RX_BUFFER_CNT 12U +#define ETH_TX_BUFFER_MAX ((ETH_TX_DESC_CNT) * 2U) + #define DMA_DESCRIPTOR_ALIGNMENT 0x20 /* Private macro -------------------------------------------------------------*/ /* Private variables ---------------------------------------------------------*/ /* @Note: This interface is implemented to operate in zero-copy mode only: - - Rx buffers are allocated statically and passed directly to the LwIP stack - they will return back to DMA after been processed by the stack. + - Rx buffers are allocated statically and passed directly to the LwIP +stack they will return back to DMA after been processed by the stack. - Tx Buffers will be allocated from LwIP stack memory heap, then passed to ETH HAL driver. @@ -87,74 +93,97 @@ 2.b. Rx Buffers must have the same size: ETH_RX_BUFFER_SIZE, this value must passed to ETH DMA in the init field (EthHandle.Init.RxBuffLen) */ +typedef enum +{ + RX_ALLOC_OK = 0x00, + RX_ALLOC_ERROR = 0x01 +} RxAllocStatusTypeDef; + +typedef struct +{ + struct pbuf_custom pbuf_custom; + uint8_t buff[(ETH_RX_BUFFER_SIZE + 31) & ~31] __ALIGNED(32); +} RxBuff_t; #if defined(__ICCARM__) /*!< IAR Compiler */ -#pragma location = 0x30040000 -ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT]; /* Ethernet Rx DMA Descriptors */ -#pragma location = 0x30040060 -ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT]; /* Ethernet Tx DMA Descriptors */ -#pragma location = 0x30040200 -uint8_t Rx_Buff[ETH_RX_DESC_CNT][ETH_RX_BUFFER_SIZE]; /* Ethernet Receive Buffers */ +#pragma location=0x30000000 +ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT]; /* Ethernet Rx DMA Descriptors */ +#pragma location=0x30000200 +ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT]; /* Ethernet Tx DMA Descriptors */ + #elif defined(__CC_ARM) /* MDK ARM Compiler */ -__attribute__((section(".RxDecripSection"))) -ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT]; /* Ethernet Rx DMA Descriptors */ -__attribute__((section(".TxDecripSection"))) -ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT]; /* Ethernet Tx DMA Descriptors */ -__attribute__((section(".RxArraySection"))) -uint8_t Rx_Buff[ETH_RX_DESC_CNT][ETH_RX_BUFFER_SIZE]; /* Ethernet Receive Buffer */ +__attribute__((section(".RxDecripSection"))) ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT]; /* Ethernet Rx DMA Descriptors */ +__attribute__((section(".TxDecripSection"))) ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT]; /* Ethernet Tx DMA Descriptors */ #elif defined(__GNUC__) /* GNU Compiler */ #ifdef FSFW_OSAL_RTEMS /* Put into special RTEMS section and align correctly */ -ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT] - __attribute__((section(".bsp_nocache"), - __aligned__(DMA_DESCRIPTOR_ALIGNMENT))); /* Ethernet Rx DMA Descriptors */ +ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT] __attribute__(( + section(".bsp_nocache"), + __aligned__(DMA_DESCRIPTOR_ALIGNMENT))); /* Ethernet Rx DMA Descriptors */ /* Put into special RTEMS section and align correctly */ -ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT] - __attribute__((section(".bsp_nocache"), - __aligned__(DMA_DESCRIPTOR_ALIGNMENT))); /* Ethernet Tx DMA Descriptors */ -/* Ethernet Receive Buffers. Just place somewhere is BSS instead of explicitely placing it */ +ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT] __attribute__(( + section(".bsp_nocache"), + __aligned__(DMA_DESCRIPTOR_ALIGNMENT))); /* Ethernet Tx DMA Descriptors */ +/* Ethernet Receive Buffers. Just place somewhere is BSS instead of explicitely + * placing it */ uint8_t Rx_Buff[ETH_RX_DESC_CNT][ETH_RX_BUFFER_SIZE]; #elif defined FSFW_OSAL_FREERTOS -/* Placement and alignment specified in linker script here */ -ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT] - __attribute__((section(".RxDecripSection"))); /* Ethernet Rx DMA Descriptors */ -ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT] - __attribute__((section(".TxDecripSection"))); /* Ethernet Tx DMA Descriptors */ -uint8_t Rx_Buff[ETH_RX_DESC_CNT][ETH_RX_BUFFER_SIZE] - __attribute__((section(".RxArraySection"))); /* Ethernet Receive Buffers */ -#endif /* FSFW_FREERTOS */ + +ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT] __attribute__((section(".RxDecripSection"))); /* Ethernet Rx DMA Descriptors */ +ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT] __attribute__((section(".TxDecripSection"))); /* Ethernet Tx DMA Descriptors */ + +#endif /* FSFW_OSAL_RTEMS */ #endif /* defined ( __GNUC__ ) */ +/* Memory Pool Declaration */ +LWIP_MEMPOOL_DECLARE(RX_POOL, ETH_RX_BUFFER_CNT, sizeof(RxBuff_t), "Zero-copy RX PBUF pool"); + +#if defined ( __ICCARM__ ) /*!< IAR Compiler */ +#pragma location = 0x30000400 +extern u8_t memp_memory_RX_POOL_base[]; + +#elif defined ( __CC_ARM ) /* MDK ARM Compiler */ +__attribute__((section(".Rx_PoolSection"))) extern u8_t memp_memory_RX_POOL_base[]; + +#elif defined ( __GNUC__ ) /* GNU Compiler */ +__attribute__((section(".Rx_PoolSection"))) extern u8_t memp_memory_RX_POOL_base[]; + +#endif + /* Global boolean to track ethernet connection */ bool ethernet_cable_connected; -struct pbuf_custom rx_pbuf[ETH_RX_DESC_CNT]; -uint32_t current_pbuf_idx = 0; +/* Variable Definitions */ +static uint8_t RxAllocStatus; +/* Global Ethernet handle*/ ETH_HandleTypeDef EthHandle; ETH_TxPacketConfig TxConfig; -lan8742_Object_t LAN8742; - /* Private function prototypes -----------------------------------------------*/ u32_t sys_now(void); -void pbuf_free_custom(struct pbuf *p); - +extern void Error_Handler(void); int32_t ETH_PHY_IO_Init(void); -int32_t ETH_PHY_IO_DeInit(void); +int32_t ETH_PHY_IO_DeInit (void); int32_t ETH_PHY_IO_ReadReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t *pRegVal); int32_t ETH_PHY_IO_WriteReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t RegVal); int32_t ETH_PHY_IO_GetTick(void); -lan8742_IOCtx_t LAN8742_IOCtx = {ETH_PHY_IO_Init, ETH_PHY_IO_DeInit, ETH_PHY_IO_WriteReg, - ETH_PHY_IO_ReadReg, ETH_PHY_IO_GetTick}; +lan8742_Object_t LAN8742; +lan8742_IOCtx_t LAN8742_IOCtx = {ETH_PHY_IO_Init, + ETH_PHY_IO_DeInit, + ETH_PHY_IO_WriteReg, + ETH_PHY_IO_ReadReg, + ETH_PHY_IO_GetTick}; + /* Private functions ---------------------------------------------------------*/ +void pbuf_free_custom(struct pbuf *p); /******************************************************************************* LL Driver Interface ( LwIP stack --> ETH) *******************************************************************************/ @@ -166,9 +195,7 @@ lan8742_IOCtx_t LAN8742_IOCtx = {ETH_PHY_IO_Init, ETH_PHY_IO_DeInit, ETH_PHY_IO_ * for this ethernetif */ static void low_level_init(struct netif *netif) { - uint32_t idx = 0; - uint8_t macaddress[6] = {ETH_MAC_ADDR0, ETH_MAC_ADDR1, ETH_MAC_ADDR2, - ETH_MAC_ADDR3, ETH_MAC_ADDR4, ETH_MAC_ADDR5}; + uint8_t macaddress[6]= {ETH_MAC_ADDR0, ETH_MAC_ADDR1, ETH_MAC_ADDR2, ETH_MAC_ADDR3, ETH_MAC_ADDR4, ETH_MAC_ADDR5}; EthHandle.Instance = ETH; EthHandle.Init.MACAddr = macaddress; @@ -181,15 +208,15 @@ static void low_level_init(struct netif *netif) { HAL_ETH_Init(&EthHandle); /* set MAC hardware address length */ - netif->hwaddr_len = ETHARP_HWADDR_LEN; + netif->hwaddr_len = ETH_HWADDR_LEN; /* set MAC hardware address */ - netif->hwaddr[0] = 0x02; - netif->hwaddr[1] = 0x00; - netif->hwaddr[2] = 0x00; - netif->hwaddr[3] = 0x00; - netif->hwaddr[4] = 0x00; - netif->hwaddr[5] = 0x00; + netif->hwaddr[0] = ETH_MAC_ADDR0; + netif->hwaddr[1] = ETH_MAC_ADDR1; + netif->hwaddr[2] = ETH_MAC_ADDR2; + netif->hwaddr[3] = ETH_MAC_ADDR3; + netif->hwaddr[4] = ETH_MAC_ADDR4; + netif->hwaddr[5] = ETH_MAC_ADDR5; /* maximum transfer unit */ netif->mtu = ETH_MAX_PAYLOAD; @@ -198,15 +225,11 @@ static void low_level_init(struct netif *netif) { /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */ netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP; - for (idx = 0; idx < ETH_RX_DESC_CNT; idx++) { - HAL_ETH_DescAssignMemory(&EthHandle, idx, Rx_Buff[idx], NULL); - - /* Set Custom pbuf free function */ - rx_pbuf[idx].custom_free_function = pbuf_free_custom; - } + /* Initialize the RX POOL */ + LWIP_MEMPOOL_INIT(RX_POOL); /* Set Tx packet config common parameters */ - memset(&TxConfig, 0, sizeof(ETH_TxPacketConfig)); + memset(&TxConfig, 0 , sizeof(ETH_TxPacketConfig)); TxConfig.Attributes = ETH_TX_PACKETS_FEATURES_CSUM | ETH_TX_PACKETS_FEATURES_CRCPAD; TxConfig.ChecksumCtrl = ETH_CHECKSUM_IPHDR_PAYLOAD_INSERT_PHDR_CALC; TxConfig.CRCPadCtrl = ETH_CRC_PAD_INSERT; @@ -221,12 +244,13 @@ static void low_level_init(struct netif *netif) { } /** - * @brief This function should do the actual transmission of the packet. The packet is - * contained in the pbuf that is passed to the function. This pbuf + * @brief This function should do the actual transmission of the packet. The + * packet is contained in the pbuf that is passed to the function. This pbuf * might be chained. * * @param netif the lwip network interface structure for this ethernetif - * @param p the MAC packet to send (e.g. IP packet including MAC addresses and type) + * @param p the MAC packet to send (e.g. IP packet including MAC addresses and + * type) * @return ERR_OK if the packet could be sent * an err_t value if the packet couldn't be sent * @@ -236,38 +260,43 @@ static void low_level_init(struct netif *netif) { * dropped because of memory failure (except for the TCP timers). */ static err_t low_level_output(struct netif *netif, struct pbuf *p) { - uint32_t i = 0, framelen = 0; - struct pbuf *q; + uint32_t i = 0U; + struct pbuf *q = NULL; err_t errval = ERR_OK; - ETH_BufferTypeDef Txbuffer[ETH_TX_DESC_CNT]; + ETH_BufferTypeDef Txbuffer[ETH_TX_DESC_CNT] = {0}; - for (q = p; q != NULL; q = q->next) { - if (i >= ETH_TX_DESC_CNT) return ERR_IF; + memset(Txbuffer, 0 , ETH_TX_DESC_CNT*sizeof(ETH_BufferTypeDef)); + + for(q = p; q != NULL; q = q->next) + { + if(i >= ETH_TX_DESC_CNT) + return ERR_IF; Txbuffer[i].buffer = q->payload; Txbuffer[i].len = q->len; - framelen += q->len; - if (i > 0) { - Txbuffer[i - 1].next = &Txbuffer[i]; + if(i>0) + { + Txbuffer[i-1].next = &Txbuffer[i]; } - if (q->next == NULL) { + if(q->next == NULL) + { Txbuffer[i].next = NULL; } i++; } - TxConfig.Length = framelen; + TxConfig.Length = p->tot_len; TxConfig.TxBuffer = Txbuffer; + TxConfig.pData = p; - HAL_StatusTypeDef ret = HAL_ETH_Transmit(&EthHandle, &TxConfig, 20); - + HAL_StatusTypeDef ret = HAL_ETH_Transmit(&EthHandle, &TxConfig, ETH_DMA_TRANSMIT_TIMEOUT); if (ret != HAL_OK) { - printf("low_level_output: Could not transmit ethernet packet, code %d!\n\r", ret); + printf("low_level_output: Could not transmit ethernet packet, code %d!\n\r", + ret); } - return errval; } @@ -281,59 +310,40 @@ static err_t low_level_output(struct netif *netif, struct pbuf *p) { */ static struct pbuf *low_level_input(struct netif *netif) { struct pbuf *p = NULL; - ETH_BufferTypeDef RxBuff; - uint32_t framelength = 0; - if (HAL_ETH_IsRxDataAvailable(&EthHandle)) { - HAL_ETH_GetRxDataBuffer(&EthHandle, &RxBuff); - HAL_ETH_GetRxDataLength(&EthHandle, &framelength); - - /* Invalidate data cache for ETH Rx Buffers */ - SCB_InvalidateDCache_by_Addr((uint32_t *)Rx_Buff, (ETH_RX_DESC_CNT * ETH_RX_BUFFER_SIZE)); - - p = pbuf_alloced_custom(PBUF_RAW, framelength, PBUF_POOL, &rx_pbuf[current_pbuf_idx], - RxBuff.buffer, ETH_RX_BUFFER_SIZE); - if (current_pbuf_idx < (ETH_RX_DESC_CNT - 1)) { - current_pbuf_idx++; - } else { - current_pbuf_idx = 0; - } - - return p; - } else { - return NULL; + if(RxAllocStatus == RX_ALLOC_OK) + { + HAL_ETH_ReadData(&EthHandle, (void **)&p); } + + return p; } /** - * @brief This function is the ethernetif_input task, it is processed when a packet - * is ready to be read from the interface. It uses the function low_level_input() - * that should handle the actual reception of bytes from the network - * interface. Then the type of the received packet is determined and - * the appropriate input function is called. + * @brief This function is the ethernetif_input task, it is processed when a + * packet is ready to be read from the interface. It uses the function + * low_level_input() that should handle the actual reception of bytes from the + * network interface. Then the type of the received packet is determined and the + * appropriate input function is called. * * @param netif the lwip network interface structure for this ethernetif */ void ethernetif_input(struct netif *netif) { - err_t err; - struct pbuf *p; + struct pbuf *p = NULL; - /* move received packet into a new pbuf */ - p = low_level_input(netif); + do + { + p = low_level_input( netif ); + if (p != NULL) + { + if (netif->input( p, netif) != ERR_OK ) + { + pbuf_free(p); + } + } - /* no packet could be read, silently ignore this */ - if (p == NULL) return; + } while(p!=NULL); - /* entry point to the LwIP stack */ - err = netif->input(p, netif); - - if (err != ERR_OK) { - LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n")); - pbuf_free(p); - p = NULL; - } - - HAL_ETH_BuildRxDescriptors(&EthHandle); } /** @@ -358,6 +368,7 @@ err_t ethernetif_init(struct netif *netif) { netif->name[0] = IFNAME0; netif->name[1] = IFNAME1; + /* We directly use etharp_output() here to save a function call. * You can instead declare your own function an call etharp_output() * from it if you have to do some checks before sending (e.g. if link @@ -377,12 +388,13 @@ err_t ethernetif_init(struct netif *netif) { * @retval None */ void pbuf_free_custom(struct pbuf *p) { - if (p != NULL) { - p->flags = 0; - p->next = NULL; - p->len = p->tot_len = 0; - p->ref = 0; - p->payload = NULL; + struct pbuf_custom* custom_pbuf = (struct pbuf_custom*)p; + LWIP_MEMPOOL_FREE(RX_POOL, custom_pbuf); + /* If the Rx Buffer Pool was exhausted, signal the ethernetif_input task to + * call HAL_ETH_GetRxDataBuffer to rebuild the Rx descriptors. */ + if (RxAllocStatus == RX_ALLOC_ERROR) + { + RxAllocStatus = RX_ALLOC_OK; } } @@ -413,7 +425,8 @@ void HAL_ETH_MspInit(ETH_HandleTypeDef *heth) { __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_GPIOG_CLK_ENABLE(); - /* Ethernet pins configuration ************************************************/ + /* Ethernet pins configuration + * ************************************************/ /* RMII_REF_CLK ----------------------> PA1 RMII_MDIO -------------------------> PA2 @@ -492,8 +505,10 @@ int32_t ETH_PHY_IO_DeInit(void) { return 0; } * @param pRegVal: pointer to hold the register value * @retval 0 if OK -1 if Error */ -int32_t ETH_PHY_IO_ReadReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t *pRegVal) { - if (HAL_ETH_ReadPHYRegister(&EthHandle, DevAddr, RegAddr, pRegVal) != HAL_OK) { +int32_t ETH_PHY_IO_ReadReg(uint32_t DevAddr, uint32_t RegAddr, + uint32_t *pRegVal) { + if (HAL_ETH_ReadPHYRegister(&EthHandle, DevAddr, RegAddr, pRegVal) != + HAL_OK) { return -1; } @@ -507,8 +522,10 @@ int32_t ETH_PHY_IO_ReadReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t *pRegVal * @param RegVal: Value to be written * @retval 0 if OK -1 if Error */ -int32_t ETH_PHY_IO_WriteReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t RegVal) { - if (HAL_ETH_WritePHYRegister(&EthHandle, DevAddr, RegAddr, RegVal) != HAL_OK) { +int32_t ETH_PHY_IO_WriteReg(uint32_t DevAddr, uint32_t RegAddr, + uint32_t RegVal) { + if (HAL_ETH_WritePHYRegister(&EthHandle, DevAddr, RegAddr, RegVal) != + HAL_OK) { return -1; } @@ -526,55 +543,121 @@ int32_t ETH_PHY_IO_GetTick(void) { return HAL_GetTick(); } * @retval None */ void ethernet_link_check_state(struct netif *netif) { - ETH_MACConfigTypeDef MACConf; - uint32_t PHYLinkState; - uint32_t linkchanged = 0, speed = 0, duplex = 0; + ETH_MACConfigTypeDef MACConf = {0}; + int32_t PHYLinkState = 0U; + uint32_t linkchanged = 0U, speed = 0U, duplex = 0U; PHYLinkState = LAN8742_GetLinkState(&LAN8742); - if (netif_is_link_up(netif) && (PHYLinkState <= LAN8742_STATUS_LINK_DOWN)) { - HAL_ETH_Stop(&EthHandle); + if(netif_is_link_up(netif) && (PHYLinkState <= LAN8742_STATUS_LINK_DOWN)) + { + HAL_ETH_Stop_IT(&EthHandle); netif_set_down(netif); netif_set_link_down(netif); - } else if (!netif_is_link_up(netif) && (PHYLinkState > LAN8742_STATUS_LINK_DOWN)) { - switch (PHYLinkState) { - case LAN8742_STATUS_100MBITS_FULLDUPLEX: - duplex = ETH_FULLDUPLEX_MODE; - speed = ETH_SPEED_100M; - linkchanged = 1; - break; - case LAN8742_STATUS_100MBITS_HALFDUPLEX: - duplex = ETH_HALFDUPLEX_MODE; - speed = ETH_SPEED_100M; - linkchanged = 1; - break; - case LAN8742_STATUS_10MBITS_FULLDUPLEX: - duplex = ETH_FULLDUPLEX_MODE; - speed = ETH_SPEED_10M; - linkchanged = 1; - break; - case LAN8742_STATUS_10MBITS_HALFDUPLEX: - duplex = ETH_HALFDUPLEX_MODE; - speed = ETH_SPEED_10M; - linkchanged = 1; - break; - default: - break; + } + else if(!netif_is_link_up(netif) && (PHYLinkState > LAN8742_STATUS_LINK_DOWN)) + { + switch (PHYLinkState) + { + case LAN8742_STATUS_100MBITS_FULLDUPLEX: + duplex = ETH_FULLDUPLEX_MODE; + speed = ETH_SPEED_100M; + linkchanged = 1; + break; + case LAN8742_STATUS_100MBITS_HALFDUPLEX: + duplex = ETH_HALFDUPLEX_MODE; + speed = ETH_SPEED_100M; + linkchanged = 1; + break; + case LAN8742_STATUS_10MBITS_FULLDUPLEX: + duplex = ETH_FULLDUPLEX_MODE; + speed = ETH_SPEED_10M; + linkchanged = 1; + break; + case LAN8742_STATUS_10MBITS_HALFDUPLEX: + duplex = ETH_HALFDUPLEX_MODE; + speed = ETH_SPEED_10M; + linkchanged = 1; + break; + default: + break; } - if (linkchanged) { + if(linkchanged) + { /* Get MAC Config MAC */ HAL_ETH_GetMACConfig(&EthHandle, &MACConf); MACConf.DuplexMode = duplex; MACConf.Speed = speed; HAL_ETH_SetMACConfig(&EthHandle, &MACConf); - HAL_ETH_Start(&EthHandle); + HAL_ETH_Start_IT(&EthHandle); netif_set_up(netif); netif_set_link_up(netif); } } } +void HAL_ETH_RxAllocateCallback(uint8_t **buff) +{ + struct pbuf_custom *p = LWIP_MEMPOOL_ALLOC(RX_POOL); + if (p) + { + /* Get the buff from the struct pbuf address. */ + *buff = (uint8_t *)p + offsetof(RxBuff_t, buff); + p->custom_free_function = pbuf_free_custom; + /* Initialize the struct pbuf. + * This must be performed whenever a buffer's allocated because it may be + * changed by lwIP or the app, e.g., pbuf_free decrements ref. */ + pbuf_alloced_custom(PBUF_RAW, 0, PBUF_REF, p, *buff, ETH_RX_BUFFER_SIZE); + } + else + { + RxAllocStatus = RX_ALLOC_ERROR; + *buff = NULL; + } +} + +void HAL_ETH_RxLinkCallback(void **pStart, void **pEnd, uint8_t *buff, uint16_t Length) +{ + struct pbuf **ppStart = (struct pbuf **)pStart; + struct pbuf **ppEnd = (struct pbuf **)pEnd; + struct pbuf *p = NULL; + + /* Get the struct pbuf from the buff address. */ + p = (struct pbuf *)(buff - offsetof(RxBuff_t, buff)); + p->next = NULL; + p->tot_len = 0; + p->len = Length; + + /* Chain the buffer. */ + if (!*ppStart) + { + /* The first buffer of the packet. */ + *ppStart = p; + } + else + { + /* Chain the buffer to the end of the packet. */ + (*ppEnd)->next = p; + } + *ppEnd = p; + + /* Update the total length of all the buffers of the chain. Each pbuf in the chain should have its tot_len + * set to its own length, plus the length of all the following pbufs in the chain. */ + for (p = *ppStart; p != NULL; p = p->next) + { + p->tot_len += Length; + } + + /* Invalidate data cache because Rx DMA's writing to physical memory makes it stale. */ + SCB_InvalidateDCache_by_Addr((uint32_t *)buff, Length); +} + +void HAL_ETH_TxFreeCallback(uint32_t * buff) +{ + pbuf_free((struct pbuf *)buff); +} + ETH_HandleTypeDef *getEthernetHandle() { return &EthHandle; } /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/stm32h7/networking/ethernetif.h b/stm32h7/networking/ethernetif.h index 85f70b8..147883f 100644 --- a/stm32h7/networking/ethernetif.h +++ b/stm32h7/networking/ethernetif.h @@ -46,7 +46,6 @@ #ifndef __ETHERNETIF_H__ #define __ETHERNETIF_H__ -#include #include #include "lwip/err.h" @@ -56,8 +55,6 @@ extern "C" { #endif -#define ETH_RX_BUFFER_SIZE (1536UL) - /* Exported types ------------------------------------------------------------*/ ETH_HandleTypeDef *getEthernetHandle(); @@ -67,7 +64,6 @@ void ethernet_link_check_state(struct netif *netif); extern ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT]; extern ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT]; -extern uint8_t Rx_Buff[ETH_RX_DESC_CNT][ETH_RX_BUFFER_SIZE]; #ifdef __cplusplus } diff --git a/stm32h7/networking/networking.cpp b/stm32h7/networking/networking.cpp index 0c4df6e..dfa4ad7 100644 --- a/stm32h7/networking/networking.cpp +++ b/stm32h7/networking/networking.cpp @@ -4,11 +4,14 @@ bool ethernetCableConnected = false; -void networking::setEthCableConnected(bool status) { ethernetCableConnected = status; } +void networking::setEthCableConnected(bool status) { + ethernetCableConnected = status; +} bool networking::getEthCableConnected() { return ethernetCableConnected; } -void networking::setLwipAddresses(ip_addr_t* ipaddr, ip_addr_t* netmask, ip_addr_t* gw) { +void networking::setLwipAddresses(ip_addr_t *ipaddr, ip_addr_t *netmask, + ip_addr_t *gw) { IP4_ADDR(ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3); IP4_ADDR(netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3); IP4_ADDR(gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3); diff --git a/stm32h7/networking/networking.h b/stm32h7/networking/networking.h index a0f9221..9e53408 100644 --- a/stm32h7/networking/networking.h +++ b/stm32h7/networking/networking.h @@ -7,8 +7,8 @@ namespace networking { void setEthCableConnected(bool status); bool getEthCableConnected(); -void setLwipAddresses(ip_addr_t* ipaddr, ip_addr_t* netmask, ip_addr_t* gw); +void setLwipAddresses(ip_addr_t *ipaddr, ip_addr_t *netmask, ip_addr_t *gw); -} // namespace networking +} // namespace networking #endif /* BSP_STM32H7_RTEMS_NETWORKING_NETWORKING_H_ */ diff --git a/stm32h7/networking/udp_config.h b/stm32h7/networking/udp_config.h index 06b4e37..95c8945 100644 --- a/stm32h7/networking/udp_config.h +++ b/stm32h7/networking/udp_config.h @@ -8,7 +8,8 @@ extern "C" { /* UDP local connection port. Client needs to bind to this port */ #define UDP_SERVER_PORT 7 -/*Static DEST IP ADDRESS: DEST_IP_ADDR0.DEST_IP_ADDR1.DEST_IP_ADDR2.DEST_IP_ADDR3 */ +/*Static DEST IP ADDRESS: + * DEST_IP_ADDR0.DEST_IP_ADDR1.DEST_IP_ADDR2.DEST_IP_ADDR3 */ #define DEST_IP_ADDR0 ((uint8_t)169U) #define DEST_IP_ADDR1 ((uint8_t)254U) #define DEST_IP_ADDR2 ((uint8_t)39U)