fsfw/timemanager/Clock.h

#ifndef FSFW_TIMEMANAGER_CLOCK_H_
#define FSFW_TIMEMANAGER_CLOCK_H_

#include "clockDefinitions.h"
#include "../returnvalues/HasReturnvaluesIF.h"
#include "../ipc/MutexFactory.h"
#include "../globalfunctions/timevalOperations.h"

#include <cstdint>

#ifdef WIN32
#include <winsock2.h>
#else
#include <sys/time.h>
#endif

class Clock {
public:
	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.
	 */
	static ReturnValue_t setClock(const TimeOfDay_t *time);
	/**
	 * 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.
	 */
	static ReturnValue_t setClock(const timeval *time);
	/**
	 * 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.
	 */
	static ReturnValue_t getClock_timeval(timeval *time);

	/**
	 * 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()
	 */
	static ReturnValue_t getUptime(timeval *uptime);

	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.
	 */
	static ReturnValue_t getUptime(uint32_t *uptimeMs);

	/**
	 * 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.
	 */
	static ReturnValue_t getClock_usecs(uint64_t *time);
	/**
	 * 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.
	 */
	static ReturnValue_t getDateAndTime(TimeOfDay_t *time);

	/**
	 * 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.
	 */
	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t *from,
			timeval *to);

	/**
	 * 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
	 */
	static ReturnValue_t convertTimevalToJD2000(timeval time, double *JD2000);

	/**
	 * Calculates and adds the offset between UTC and TT
	 *
	 * Depends on the leap seconds to be set correctly.
	 * Therefore, it does not work for historic
	 * dates as only the current leap seconds are known.
	 *
	 * @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
	 */
	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;
	}

	/**
	 * Set the Leap Seconds since 1972
	 *
	 * @param leapSeconds_
	 * @return
	 *  - @c RETURN_OK on success.
	 */
	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;
	}

	/**
	 * Get the Leap Seconds since 1972
	 *
	 * Setter must be called before
	 *
	 * @param[out] leapSeconds_
	 * @return
	 *  - @c RETURN_OK on success.
	 *  - @c RETURN_FAILED on error
	 */
	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
	ReturnValue_t Clock::getLeapSeconds(uint16_t *leapSeconds_) {
		if (timeMutex == nullptr) {
			return HasReturnvaluesIF::RETURN_FAILED;
		}
		MutexGuard helper(timeMutex);

		*leapSeconds_ = leapSeconds;

		return HasReturnvaluesIF::RETURN_OK;
	}

private:
	/**
	 * 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
	 */
	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;
	static uint16_t leapSeconds;
};

#endif /* FSFW_TIMEMANAGER_CLOCK_H_ */