various changes, stopwatch

Semaphore: Some bugfixes, some constructors added
Stopwatch: First implementation, can measure in ms(double) and
ms(normal)

timemanager/CCSDSTime.cpp

@@ -196,7 +196,8 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		to->usecond = (second - floor(second)) * 1000000;
 		return RETURN_OK;
 	}
-// Warning: Compiler/Linker fails ambiguously if library does not implement C99 I/O
+// Warning: Compiler/Linker fails ambiguously if library does not implement
+// C99 I/O
 #else
 	uint16_t year;
 	uint8_t month;

timemanager/Clock.h

@@ -7,7 +7,8 @@
 #include <framework/ipc/MutexFactory.h>
 #include <framework/globalfunctions/timevalOperations.h>
 
-
+typedef uint32_t ms_normal_t;
+typedef double ms_double_t;
 
 class Clock {
 public:

timemanager/Stopwatch.cpp

@@ -0,0 +1,62 @@
+/**
+ * @file Stopwatch.cpp
+ *
+ * @date 08.04.2020
+ */
+
+#include <framework/timemanager/Stopwatch.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+Stopwatch::Stopwatch(bool displayOnDestruction, DisplayMode displayMode):
+        displayOnDestruction(displayOnDestruction) {
+    Clock::getUptime(&startTime);
+    stopwatchState = StopwatchState::STARTED;
+}
+
+void Stopwatch::start() {
+    startTime = Clock::getUptime();
+}
+
+ms_normal_t Stopwatch::stop() {
+    elapsedTime = Clock::getUptime() - startTime;
+    int32_t elapsedTimeMs = elapsedTime.tv_sec * 1000 +
+            elapsedTime.tv_usec/1000;
+    if(elapsedTimeMs < 0) {
+        error << "Stopwatch: Measured time negative!";
+        return INVALID_TIME;
+    }
+    else {
+        return static_cast<ms_normal_t>(elapsedTimeMs);
+    }
+}
+
+ms_double_t Stopwatch::stopPrecise() {
+    elapsedTime = Clock::getUptime() - startTime;
+    return timevalOperations::toDouble(elapsedTime) * 1000.0;
+}
+
+
+void Stopwatch::display() {
+    if(displayMode == DisplayMode::MS_FLOAT) {
+        info << "Stopwatch: Operation took " <<
+                elapsedTimeMs << " milliseconds" << std::endl;
+    }
+    else {
+        timeval elapsedTime = stopTime - startTime;
+        info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
+                elapsedTime.tv_usec * 1000 << " milliseconds";
+    }
+}
+
+
+Stopwatch::~Stopwatch() {
+    if(displayOnDestruction) {
+        stopInternal();
+        display();
+    }
+}
+
+void Stopwatch::stopInternal() {
+    elapsedTime = Clock::getUptime() - startTime;
+    elapsedTimeMs = timevalOperations::toDouble(elapsedTime) * 1000.0;
+}

timemanager/Stopwatch.h

@@ -0,0 +1,52 @@
+/**
+ * @file Stopwatch.h
+ *
+ * @date 08.04.2020
+ */
+
+#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#include <framework/timemanager/Clock.h>
+
+class Stopwatch {
+    enum class DisplayMode {
+        MS_FLOAT,
+        MS
+    };
+
+    Stopwatch(bool displayOnDestruction = true, DisplayMode displayMode =
+            DisplayMode::MS_FLOAT);
+    virtual~ Stopwatch();
+
+    void start();
+
+    ms_normal_t stop();
+    ms_double_t stopPrecise();
+
+    void display();
+private:
+    static const ms_normal_t INVALID_TIME = 0xFFFFFFFF;
+
+    timeval startTime {0, 0};
+    timeval stopTime {0, 0};
+    timeval elapsedTime {0, 0};
+    double elapsedTimeMs = 0;
+    //ms_normal_t elapsedTimeMs {0};
+
+    bool displayOnDestruction = true;
+
+    enum class StopwatchState {
+        IDLE,
+        STARTED,
+    };
+
+    StopwatchState stopwatchState = StopwatchState::IDLE;
+    DisplayMode displayMode = DisplayMode::MS_FLOAT;
+
+    void stopInternal();
+};
+
+
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ */