fsfw/timemanager/Clock.h

225 lines
6.5 KiB
C
Raw Normal View History

2020-12-14 11:17:22 +01:00
#ifndef FSFW_TIMEMANAGER_CLOCK_H_
#define FSFW_TIMEMANAGER_CLOCK_H_
2020-12-15 23:00:30 +01:00
#include "clockDefinitions.h"
2020-08-13 20:53:35 +02:00
#include "../returnvalues/HasReturnvaluesIF.h"
2020-12-15 23:00:30 +01:00
#include "../ipc/MutexFactory.h"
2020-08-13 20:53:35 +02:00
#include "../globalfunctions/timevalOperations.h"
2020-05-29 17:45:08 +02:00
#include <cstdint>
2020-12-21 14:07:06 +01:00
#ifdef WIN32
#include <winsock2.h>
#else
2020-05-29 17:45:08 +02:00
#include <sys/time.h>
2020-12-20 15:32:03 +01:00
#endif
2020-05-29 17:45:08 +02:00
class Clock {
public:
2020-12-22 15:29:42 +01:00
typedef struct {
uint32_t year; //!< Year, A.D.
uint32_t month; //!< Month, 1 .. 12.
uint32_t day; //!< Day, 1 .. 31.
uint32_t hour; //!< Hour, 0 .. 23.
uint32_t minute; //!< Minute, 0 .. 59.
uint32_t second; //!< Second, 0 .. 59.
uint32_t usecond; //!< Microseconds, 0 .. 999999
} TimeOfDay_t;
/**
* This method returns the number of clock ticks per second.
* In RTEMS, this is typically 1000.
* @return The number of ticks.
*
* @deprecated, we should not worry about ticks, but only time
*/
static uint32_t getTicksPerSecond(void);
/**
* This system call sets the system time.
* To set the time, it uses a TimeOfDay_t struct.
* @param time The struct with the time settings to set.
* @return -@c RETURN_OK on success. Otherwise, the OS failure code
* is returned.
*/
2021-06-14 14:40:40 +02:00
static ReturnValue_t setClock(const TimeOfDay_t *time);
2020-12-22 15:29:42 +01:00
/**
* This system call sets the system time.
* To set the time, it uses a timeval struct.
* @param time The struct with the time settings to set.
* @return -@c RETURN_OK on success. Otherwise, the OS failure code is returned.
*/
2021-06-14 14:40:40 +02:00
static ReturnValue_t setClock(const timeval *time);
2020-12-22 15:29:42 +01:00
/**
* This system call returns the current system clock in timeval format.
* The timval format has the fields @c tv_sec with seconds and @c tv_usec with
* microseconds since an OS-defined epoch.
* @param time A pointer to a timeval struct where the current time is stored.
* @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
*/
2021-06-14 14:40:40 +02:00
static ReturnValue_t getClock_timeval(timeval *time);
2020-12-22 15:29:42 +01:00
/**
* Get the time since boot in a timeval struct
*
* @param[out] time A pointer to a timeval struct where the uptime is stored.
* @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
*
* @deprecated, I do not think this should be able to fail, use timeval getUptime()
*/
2021-06-14 14:40:40 +02:00
static ReturnValue_t getUptime(timeval *uptime);
2020-12-22 15:29:42 +01:00
static timeval getUptime();
/**
* Get the time since boot in milliseconds
*
* This value can overflow! Still, it can be used to calculate time intervalls
* between two calls up to 49 days by always using uint32_t in the calculation
*
* @param ms uptime in ms
* @return RETURN_OK on success. Otherwise, the OS failure code is returned.
*/
2021-06-14 14:40:40 +02:00
static ReturnValue_t getUptime(uint32_t *uptimeMs);
2020-12-22 15:29:42 +01:00
/**
* Returns the time in microseconds since an OS-defined epoch.
* The time is returned in a 64 bit unsigned integer.
* @param time A pointer to a 64 bit unisigned integer where the data is stored.
* @return
* - @c RETURN_OK on success.
* - Otherwise, the OS failure code is returned.
*/
2021-06-14 14:40:40 +02:00
static ReturnValue_t getClock_usecs(uint64_t *time);
2020-12-22 15:29:42 +01:00
/**
* Returns the time in a TimeOfDay_t struct.
* @param time A pointer to a TimeOfDay_t struct.
* @return
* - @c RETURN_OK on success.
* - Otherwise, the OS failure code is returned.
*/
2021-06-14 14:40:40 +02:00
static ReturnValue_t getDateAndTime(TimeOfDay_t *time);
2020-12-22 15:29:42 +01:00
/**
* Converts a time of day struct to POSIX seconds.
* @param time The time of day as input
* @param timeval The corresponding seconds since the epoch.
* @return
* - @c RETURN_OK on success.
* - Otherwise, the OS failure code is returned.
*/
2021-06-14 14:40:40 +02:00
static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t *from,
timeval *to);
2020-12-22 15:29:42 +01:00
/**
* Converts a time represented as seconds and subseconds since unix
* epoch to days since J2000
*
* @param time seconds since unix epoch
* @param[out] JD2000 days since J2000
* @return @c RETURN_OK
*/
2021-06-14 14:40:40 +02:00
static ReturnValue_t convertTimevalToJD2000(timeval time, double *JD2000);
2020-12-22 15:29:42 +01:00
/**
* Calculates and adds the offset between UTC and TT
*
* Depends on the leap seconds to be set correctly.
2021-06-14 14:40:40 +02:00
* Therefore, it does not work for historic
* dates as only the current leap seconds are known.
2020-12-22 15:29:42 +01:00
*
* @param utc timeval, corresponding to UTC time
* @param[out] tt timeval, corresponding to Terrestial Time
* @return
* - @c RETURN_OK on success
* - @c RETURN_FAILED if leapSeconds are not set
*/
2021-06-14 14:40:40 +02:00
static ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval *tt) {
if (timeMutex == nullptr) {
return HasReturnvaluesIF::RETURN_FAILED;
}
uint16_t leapSeconds;
ReturnValue_t result = getLeapSeconds(&leapSeconds);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
timeval leapSeconds_timeval = { 0, 0 };
leapSeconds_timeval.tv_sec = leapSeconds;
//initial offset between UTC and TAI
timeval UTCtoTAI1972 = { 10, 0 };
timeval TAItoTT = { 32, 184000 };
*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
return HasReturnvaluesIF::RETURN_OK;
}
2020-12-22 15:29:42 +01:00
/**
* Set the Leap Seconds since 1972
*
* @param leapSeconds_
* @return
* - @c RETURN_OK on success.
*/
2021-06-14 14:40:40 +02:00
static ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
return HasReturnvaluesIF::RETURN_FAILED;
}
MutexGuard helper(timeMutex);
leapSeconds = leapSeconds_;
return HasReturnvaluesIF::RETURN_OK;
}
2020-12-22 15:29:42 +01:00
/**
* Get the Leap Seconds since 1972
*
2021-06-14 14:40:40 +02:00
* Setter must be called before
2020-12-22 15:29:42 +01:00
*
* @param[out] leapSeconds_
* @return
* - @c RETURN_OK on success.
2021-06-14 14:40:40 +02:00
* - @c RETURN_FAILED on error
2020-12-22 15:29:42 +01:00
*/
static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
2021-06-14 14:40:40 +02:00
ReturnValue_t Clock::getLeapSeconds(uint16_t *leapSeconds_) {
if (timeMutex == nullptr) {
return HasReturnvaluesIF::RETURN_FAILED;
}
MutexGuard helper(timeMutex);
*leapSeconds_ = leapSeconds;
2020-12-22 15:29:42 +01:00
2021-06-14 14:40:40 +02:00
return HasReturnvaluesIF::RETURN_OK;
}
private:
2020-12-22 15:29:42 +01:00
/**
* Function to check and create the Mutex for the clock
* @return
* - @c RETURN_OK on success.
* - Otherwise @c RETURN_FAILED if not able to create one
*/
2021-06-14 14:40:40 +02:00
static ReturnValue_t Clock::checkOrCreateClockMutex() {
if (timeMutex == nullptr) {
MutexFactory *mutexFactory = MutexFactory::instance();
if (mutexFactory == nullptr) {
return HasReturnvaluesIF::RETURN_FAILED;
}
timeMutex = mutexFactory->createMutex();
if (timeMutex == nullptr) {
return HasReturnvaluesIF::RETURN_FAILED;
}
}
return HasReturnvaluesIF::RETURN_OK;
}
static MutexIF *timeMutex;
2020-12-22 15:29:42 +01:00
static uint16_t leapSeconds;
};
2020-12-14 11:17:22 +01:00
#endif /* FSFW_TIMEMANAGER_CLOCK_H_ */