fsfw/fsfw
fsfw/fsfw
10
3
Fork 6
Code Issues 31 Pull Requests 4 Releases 10 Wiki Activity

Applied clang format
All checks were successful
fsfw/fsfw/pipeline/pr-development This commit looks good
Details

Browse Source
This commit is contained in:
Steffen Gaisser 2022-03-25 18:48:53 +01:00
parent 10398855a9
commit 665d8cd479
10 changed files with 226 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/fsfw/osal/host/Clock.cpp
View File

@ -2,9 +2,9 @@
#include <chrono> #include <chrono>
#include "fsfw/ipc/MutexGuard.h"
#include "fsfw/platform.h" #include "fsfw/platform.h"
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/ipc/MutexGuard.h"
#if defined(PLATFORM_WIN) #if defined(PLATFORM_WIN)
#include <sysinfoapi.h> #include <sysinfoapi.h>
@ -126,7 +126,7 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
auto fraction = now - seconds; auto fraction = now - seconds;
time_t tt = SystemClock::to_time_t(now); time_t tt = SystemClock::to_time_t(now);
ReturnValue_t result = checkOrCreateClockMutex(); ReturnValue_t result = checkOrCreateClockMutex();
if(result != HasReturnvaluesIF::RETURN_OK){ if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
MutexGuard helper(timeMutex); MutexGuard helper(timeMutex);

4
src/fsfw/osal/linux/Clock.cpp
View File

@ -8,8 +8,8 @@
#include <fstream> #include <fstream>
#include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw/ipc/MutexGuard.h" #include "fsfw/ipc/MutexGuard.h"
#include "fsfw/serviceinterface/ServiceInterface.h"
uint32_t Clock::getTicksPerSecond(void) { uint32_t Clock::getTicksPerSecond(void) {
uint32_t ticks = sysconf(_SC_CLK_TCK); uint32_t ticks = sysconf(_SC_CLK_TCK);
@ -116,7 +116,7 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
ReturnValue_t result = checkOrCreateClockMutex(); ReturnValue_t result = checkOrCreateClockMutex();
if(result != HasReturnvaluesIF::RETURN_OK){ if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
MutexGuard helper(timeMutex); MutexGuard helper(timeMutex);

1
src/fsfw/osal/rtems/Clock.cpp
View File

@ -6,7 +6,6 @@
#include "fsfw/ipc/MutexGuard.h" #include "fsfw/ipc/MutexGuard.h"
#include "fsfw/osal/rtems/RtemsBasic.h" #include "fsfw/osal/rtems/RtemsBasic.h"
uint32_t Clock::getTicksPerSecond(void) { uint32_t Clock::getTicksPerSecond(void) {
rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second(); rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
return static_cast<uint32_t>(ticks_per_second); return static_cast<uint32_t>(ticks_per_second);

4
src/fsfw/timemanager/ClockCommon.cpp
View File

@ -39,7 +39,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
} }
ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) { ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
if(not leapSecondsSet){ if (not leapSecondsSet) {
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) { if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
@ -58,7 +58,7 @@ ReturnValue_t Clock::convertTimevalToTimeOfDay(const timeval* from, TimeOfDay_t*
// in the Windows CRT is incompatible with the C standard but this should not be an issue for // in the Windows CRT is incompatible with the C standard but this should not be an issue for
// this implementation // this implementation
ReturnValue_t result = checkOrCreateClockMutex(); ReturnValue_t result = checkOrCreateClockMutex();
if(result != HasReturnvaluesIF::RETURN_OK){ if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
MutexGuard helper(timeMutex); MutexGuard helper(timeMutex);

3
src/fsfw/version.cpp
View File

@ -1,8 +1,9 @@
#include "version.h" #include "version.h"
#include "fsfw/FSFWVersion.h"
#include <cstdio> #include <cstdio>
#include "fsfw/FSFWVersion.h"
#ifdef major #ifdef major
#undef major #undef major
#endif #endif

2
src/fsfw/version.h
View File

@ -29,7 +29,7 @@ class Version {
} }
friend bool operator>(const Version& v1, const Version& v2) { friend bool operator>(const Version& v1, const Version& v2) {
return not (v1 < v2) and not (v1 == v2); return not(v1 < v2) and not(v1 == v2);
} }
friend bool operator<=(const Version& v1, const Version& v2) { return ((v1 == v2) or (v1 < v2)); } friend bool operator<=(const Version& v1, const Version& v2) { return ((v1 == v2) or (v1 < v2)); }

15
tests/src/fsfw_tests/unit/globalfunctions/testTimevalOperations.cpp
View File

@ -1,12 +1,12 @@
#include <catch2/catch_test_macros.hpp>
#include <catch2/catch_approx.hpp>
#include <fsfw/globalfunctions/timevalOperations.h> #include <fsfw/globalfunctions/timevalOperations.h>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
#include "fsfw_tests/unit/CatchDefinitions.h" #include "fsfw_tests/unit/CatchDefinitions.h"
TEST_CASE("TimevalTest", "[timevalOperations]"){ TEST_CASE("TimevalTest", "[timevalOperations]") {
SECTION("Comparison"){ SECTION("Comparison") {
timeval t1; timeval t1;
t1.tv_sec = 1648227422; t1.tv_sec = 1648227422;
t1.tv_usec = 123456; t1.tv_usec = 123456;
@ -54,7 +54,7 @@ TEST_CASE("TimevalTest", "[timevalOperations]"){
REQUIRE_FALSE(t1 > t4); REQUIRE_FALSE(t1 > t4);
REQUIRE(t4 > t1); REQUIRE(t4 > t1);
} }
SECTION("Operators"){ SECTION("Operators") {
timeval t1; timeval t1;
t1.tv_sec = 1648227422; t1.tv_sec = 1648227422;
t1.tv_usec = 123456; t1.tv_usec = 123456;
@ -113,7 +113,7 @@ TEST_CASE("TimevalTest", "[timevalOperations]"){
REQUIRE(scalar5 == Catch::Approx(0.5)); REQUIRE(scalar5 == Catch::Approx(0.5));
} }
SECTION("timevalOperations::toTimeval"){ SECTION("timevalOperations::toTimeval") {
double seconds = 1648227422.123456; double seconds = 1648227422.123456;
timeval t1 = timevalOperations::toTimeval(seconds); timeval t1 = timevalOperations::toTimeval(seconds);
REQUIRE(t1.tv_sec == 1648227422); REQUIRE(t1.tv_sec == 1648227422);
@ -121,5 +121,4 @@ TEST_CASE("TimevalTest", "[timevalOperations]"){
REQUIRE(t1.tv_usec >= 123455); REQUIRE(t1.tv_usec >= 123455);
REQUIRE(t1.tv_usec <= 123457); REQUIRE(t1.tv_usec <= 123457);
} }
} }

42
tests/src/fsfw_tests/unit/osal/TestClock.cpp
View File

@ -1,14 +1,14 @@
#include <fsfw/timemanager/Clock.h>
#include <fsfw/globalfunctions/timevalOperations.h> #include <fsfw/globalfunctions/timevalOperations.h>
#include <fsfw/timemanager/Clock.h>
#include <array> #include <array>
#include <catch2/catch_test_macros.hpp>
#include <catch2/catch_approx.hpp> #include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
#include "fsfw_tests/unit/CatchDefinitions.h" #include "fsfw_tests/unit/CatchDefinitions.h"
TEST_CASE("OSAL::Clock Test", "[OSAL::Clock Test]"){ TEST_CASE("OSAL::Clock Test", "[OSAL::Clock Test]") {
SECTION("Test getClock"){ SECTION("Test getClock") {
timeval time; timeval time;
ReturnValue_t result = Clock::getClock_timeval(&time); ReturnValue_t result = Clock::getClock_timeval(&time);
REQUIRE(result == HasReturnvaluesIF::RETURN_OK); REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
@ -20,9 +20,9 @@ TEST_CASE("OSAL::Clock Test", "[OSAL::Clock Test]"){
REQUIRE(result == HasReturnvaluesIF::RETURN_OK); REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
// We require timeOfDayAsTimeval to be larger than time as it // We require timeOfDayAsTimeval to be larger than time as it
// was request a few ns later // was request a few ns later
double difference = timevalOperations::toDouble(timeOfDayAsTimeval-time); double difference = timevalOperations::toDouble(timeOfDayAsTimeval - time);
CHECK(difference>=0.0); CHECK(difference >= 0.0);
CHECK(difference<=0.005); CHECK(difference <= 0.005);
// Conversion in the other direction // Conversion in the other direction
Clock::TimeOfDay_t timevalAsTimeOfDay; Clock::TimeOfDay_t timevalAsTimeOfDay;
@ -31,7 +31,7 @@ TEST_CASE("OSAL::Clock Test", "[OSAL::Clock Test]"){
CHECK(timevalAsTimeOfDay.year <= timeOfDay.year); CHECK(timevalAsTimeOfDay.year <= timeOfDay.year);
// TODO We should write TimeOfDay operators! // TODO We should write TimeOfDay operators!
} }
SECTION("Leap seconds"){ SECTION("Leap seconds") {
uint16_t leapSeconds = 0; uint16_t leapSeconds = 0;
ReturnValue_t result = Clock::getLeapSeconds(&leapSeconds); ReturnValue_t result = Clock::getLeapSeconds(&leapSeconds);
REQUIRE(result == HasReturnvaluesIF::RETURN_FAILED); REQUIRE(result == HasReturnvaluesIF::RETURN_FAILED);
@ -42,31 +42,31 @@ TEST_CASE("OSAL::Clock Test", "[OSAL::Clock Test]"){
REQUIRE(result == HasReturnvaluesIF::RETURN_OK); REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
REQUIRE(leapSeconds == 18); REQUIRE(leapSeconds == 18);
} }
SECTION("usec Test"){ SECTION("usec Test") {
timeval timeAsTimeval; timeval timeAsTimeval;
ReturnValue_t result = Clock::getClock_timeval(&timeAsTimeval); ReturnValue_t result = Clock::getClock_timeval(&timeAsTimeval);
REQUIRE(result == HasReturnvaluesIF::RETURN_OK); REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
uint64_t timeAsUsec = 0; uint64_t timeAsUsec = 0;
result = Clock::getClock_usecs(&timeAsUsec); result = Clock::getClock_usecs(&timeAsUsec);
REQUIRE(result == HasReturnvaluesIF::RETURN_OK); REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
double timeAsUsecDouble = static_cast<double>(timeAsUsec)/1000000.0; double timeAsUsecDouble = static_cast<double>(timeAsUsec) / 1000000.0;
timeval timeAsUsecTimeval = timevalOperations::toTimeval(timeAsUsecDouble); timeval timeAsUsecTimeval = timevalOperations::toTimeval(timeAsUsecDouble);
double difference = timevalOperations::toDouble(timeAsTimeval - timeAsUsecTimeval); double difference = timevalOperations::toDouble(timeAsTimeval - timeAsUsecTimeval);
// We accept 5 ms difference // We accept 5 ms difference
CHECK(abs(difference) <= 0.005); CHECK(abs(difference) <= 0.005);
uint64_t timevalAsUint64 = static_cast<uint64_t>(timeAsTimeval.tv_sec)*1000000ull + static_cast<uint64_t>(timeAsTimeval.tv_usec); uint64_t timevalAsUint64 = static_cast<uint64_t>(timeAsTimeval.tv_sec) * 1000000ull +
if(timeAsUsec > timevalAsUint64){ static_cast<uint64_t>(timeAsTimeval.tv_usec);
if (timeAsUsec > timevalAsUint64) {
// This should not be the case but we can see some rounding issue sometimes // This should not be the case but we can see some rounding issue sometimes
// This is the case if used in valgrind. This might indicate an other issue // This is the case if used in valgrind. This might indicate an other issue
CHECK((timeAsUsec - timevalAsUint64)>=0); CHECK((timeAsUsec - timevalAsUint64) >= 0);
CHECK((timeAsUsec - timevalAsUint64)<=(5*1000)); CHECK((timeAsUsec - timevalAsUint64) <= (5 * 1000));
}else{ } else {
CHECK((timevalAsUint64 - timeAsUsec)>=0); CHECK((timevalAsUint64 - timeAsUsec) >= 0);
CHECK((timevalAsUint64 - timeAsUsec)<=(5*1000)); CHECK((timevalAsUint64 - timeAsUsec) <= (5 * 1000));
} }
} }
SECTION("Test j2000"){ SECTION("Test j2000") {
double j2000; double j2000;
timeval time; timeval time;
time.tv_sec = 1648208539; time.tv_sec = 1648208539;
@ -74,9 +74,9 @@ TEST_CASE("OSAL::Clock Test", "[OSAL::Clock Test]"){
ReturnValue_t result = Clock::convertTimevalToJD2000(time, &j2000); ReturnValue_t result = Clock::convertTimevalToJD2000(time, &j2000);
REQUIRE(result == HasReturnvaluesIF::RETURN_OK); REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
double correctJ2000 = 2459663.98772 - 2451545.0; double correctJ2000 = 2459663.98772 - 2451545.0;
CHECK(j2000 == Catch::Approx(correctJ2000).margin(1.2*1e-8)); CHECK(j2000 == Catch::Approx(correctJ2000).margin(1.2 * 1e-8));
} }
SECTION("Convert to TT"){ SECTION("Convert to TT") {
timeval utcTime; timeval utcTime;
utcTime.tv_sec = 1648208539; utcTime.tv_sec = 1648208539;
utcTime.tv_usec = 999000; utcTime.tv_usec = 999000;

2
tests/src/fsfw_tests/unit/timemanager/TestCCSDSTime.cpp
View File

@ -120,8 +120,6 @@ TEST_CASE("CCSDSTime Tests", "[TestCCSDSTime]") {
CHECK(cdsTime.msDay_l == 0xC5); CHECK(cdsTime.msDay_l == 0xC5);
CHECK(cdsTime.msDay_ll == 0xC3); CHECK(cdsTime.msDay_ll == 0xC3);
// Conversion back to timeval // Conversion back to timeval
timeval timeReturnAsTimeval; timeval timeReturnAsTimeval;
result = CCSDSTime::convertFromCDS(&timeReturnAsTimeval, &cdsTime); result = CCSDSTime::convertFromCDS(&timeReturnAsTimeval, &cdsTime);

50
tests/src/fsfw_tests/unit/version.cpp
View File

@ -17,15 +17,15 @@ TEST_CASE("Version API Tests", "[TestVersionAPI]") {
fsfw::Version v1 = fsfw::Version(1, 1, 1); fsfw::Version v1 = fsfw::Version(1, 1, 1);
fsfw::Version v2 = fsfw::Version(1, 1, 1); fsfw::Version v2 = fsfw::Version(1, 1, 1);
REQUIRE(v1 == v2); REQUIRE(v1 == v2);
REQUIRE(not (v1 < v2)); REQUIRE(not(v1 < v2));
REQUIRE(not (v1 > v2)); REQUIRE(not(v1 > v2));
REQUIRE(v1 <= v2); REQUIRE(v1 <= v2);
REQUIRE(v1 >= v2); REQUIRE(v1 >= v2);
v1.revision -= 1; v1.revision -= 1;
REQUIRE(v1 != v2); REQUIRE(v1 != v2);
REQUIRE(not (v1 == v2)); REQUIRE(not(v1 == v2));
REQUIRE(not (v1 > v2)); REQUIRE(not(v1 > v2));
REQUIRE(not (v1 >= v2)); REQUIRE(not(v1 >= v2));
REQUIRE(v1 < v2); REQUIRE(v1 < v2);
REQUIRE(v1 <= v2); REQUIRE(v1 <= v2);
v1.revision += 1; v1.revision += 1;
@ -33,60 +33,60 @@ TEST_CASE("Version API Tests", "[TestVersionAPI]") {
REQUIRE(v1 != v2); REQUIRE(v1 != v2);
REQUIRE(v1 < v2); REQUIRE(v1 < v2);
REQUIRE(v1 <= v2); REQUIRE(v1 <= v2);
REQUIRE(not (v1 == v2)); REQUIRE(not(v1 == v2));
REQUIRE(not (v1 > v2)); REQUIRE(not(v1 > v2));
REQUIRE(not (v1 >= v2)); REQUIRE(not(v1 >= v2));
v1.minor += 1; v1.minor += 1;
v1.major -= 1; v1.major -= 1;
REQUIRE(v1 != v2); REQUIRE(v1 != v2);
REQUIRE(v1 < v2); REQUIRE(v1 < v2);
REQUIRE(v1 <= v2); REQUIRE(v1 <= v2);
REQUIRE(not (v1 == v2)); REQUIRE(not(v1 == v2));
REQUIRE(not (v1 > v2)); REQUIRE(not(v1 > v2));
REQUIRE(not (v1 >= v2)); REQUIRE(not(v1 >= v2));
v1.major += 1; v1.major += 1;
REQUIRE(v1 == v2); REQUIRE(v1 == v2);
REQUIRE(v1 <= v2); REQUIRE(v1 <= v2);
REQUIRE(v1 >= v2); REQUIRE(v1 >= v2);
REQUIRE(not (v1 != v2)); REQUIRE(not(v1 != v2));
REQUIRE(not (v1 > v2)); REQUIRE(not(v1 > v2));
REQUIRE(not (v1 < v2)); REQUIRE(not(v1 < v2));
v1.major += 1; v1.major += 1;
v1.minor -= 1; v1.minor -= 1;
REQUIRE(v1 != v2); REQUIRE(v1 != v2);
REQUIRE(v1 > v2); REQUIRE(v1 > v2);
REQUIRE(v1 >= v2); REQUIRE(v1 >= v2);
REQUIRE(not (v1 == v2)); REQUIRE(not(v1 == v2));
REQUIRE(not (v1 < v2)); REQUIRE(not(v1 < v2));
REQUIRE(not (v1 <= v2)); REQUIRE(not(v1 <= v2));
v1.major -= 1; v1.major -= 1;
v1.minor += 2; v1.minor += 2;
v1.revision -= 1; v1.revision -= 1;
REQUIRE(v1 != v2); REQUIRE(v1 != v2);
REQUIRE(v1 > v2); REQUIRE(v1 > v2);
REQUIRE(v1 >= v2); REQUIRE(v1 >= v2);
REQUIRE(not (v1 == v2)); REQUIRE(not(v1 == v2));
REQUIRE(not (v1 < v2)); REQUIRE(not(v1 < v2));
REQUIRE(not (v1 <= v2)); REQUIRE(not(v1 <= v2));
v1.minor -= 1; v1.minor -= 1;
v1.revision += 2; v1.revision += 2;
REQUIRE(v1 != v2); REQUIRE(v1 != v2);
REQUIRE(v1 > v2); REQUIRE(v1 > v2);
REQUIRE(v1 >= v2); REQUIRE(v1 >= v2);
REQUIRE(not (v1 == v2)); REQUIRE(not(v1 == v2));
REQUIRE(not (v1 < v2)); REQUIRE(not(v1 < v2));
REQUIRE(not (v1 <= v2)); REQUIRE(not(v1 <= v2));
v1.revision -= 1; v1.revision -= 1;
REQUIRE(v1 == v2); REQUIRE(v1 == v2);
REQUIRE(v1 <= v2); REQUIRE(v1 <= v2);
REQUIRE(v1 >= v2); REQUIRE(v1 >= v2);
REQUIRE(not (v1 != v2)); REQUIRE(not(v1 != v2));
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::info << "v" << fsfw::FSFW_VERSION << std::endl; sif::info << "v" << fsfw::FSFW_VERSION << std::endl;
#endif #endif
char verString[10] = {}; char verString[10] = {};
fsfw::FSFW_VERSION.getVersion(verString, sizeof(verString)); fsfw::FSFW_VERSION.getVersion(verString, sizeof(verString));
#if FSFW_DISABLE_PRINTOUT == 0 #if FSFW_DISABLE_PRINTOUT == 0
printf("v%s\n",verString); printf("v%s\n", verString);
#endif #endif
} }