Today's the day. Renamed platform to framework.

timemanager/CCSDSTime.cpp

@@ -0,0 +1,471 @@
+/*
+ * CCSDSTime.cpp
+ *
+ *  Created on: 22.03.2013
+ *      Author: tod
+ */
+
+#include <framework/osal/OSAL.h>
+#include <framework/timemanager/CCSDSTime.h>
+#include <stdio.h>
+#include <math.h>
+
+CCSDSTime::CCSDSTime() {
+}
+
+CCSDSTime::~CCSDSTime() {
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
+		const TimeOfDay_t* from) {
+	to->pField = (CCS << 4);
+
+	to->yearMSB = (from->year >> 8);
+	to->yearLSB = from->year & 0xff;
+	to->month = from->month;
+	to->day = from->day;
+	to->hour = from->hour;
+	to->minute = from->minute;
+	to->second = from->second;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
+		const TimeOfDay_t* from) {
+	to->pField = (CCS << 4) + 2;
+
+	to->yearMSB = (from->year >> 8);
+	to->yearLSB = from->year & 0xff;
+	to->month = from->month;
+	to->day = from->day;
+	to->hour = from->hour;
+	to->minute = from->minute;
+	to->second = from->second;
+	to->secondEminus2 = from->ticks / 10;
+	to->secondEminus4 = (from->ticks % 10) * 10;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCcsds(TimeOfDay_t* to, const uint8_t* from,
+		uint32_t length) {
+	ReturnValue_t result;
+	if (length > 0xFF) {
+		return LENGTH_MISMATCH;
+	}
+	result = convertFromASCII(to, from, length); //Try to parse it as ASCII
+	if (result == RETURN_OK) {
+		return RETURN_OK;
+	}
+
+	//Seems to be no ascii, try the other formats
+	uint8_t codeIdentification = (*from >> 4);
+	switch (codeIdentification) {
+	case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can...
+		return convertFromCUC(to, from, length);
+	case CDS:
+		return convertFromCDS(to, from, length);
+	case CCS: {
+		//SHOULDDO: Returning the actual found length is the right way to go, but for now, keep it.
+		uint32_t temp = 0;
+		return convertFromCCS(to, from, &temp, length);
+	}
+
+	default:
+		return UNSUPPORTED_TIME_FORMAT;
+	}
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::convertFromCDS(TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	timeval time;
+	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return convertTimevalToTimeOfDay(to, &time);
+}
+
+ReturnValue_t CCSDSTime::convertFromCCS(TimeOfDay_t* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	uint8_t subsecondsLength = *from & 0b111;
+	uint32_t totalLength = subsecondsLength + 8;
+	if (maxLength < totalLength) {
+		return LENGTH_MISMATCH;
+	}
+	//TODO: Check this!
+	Ccs_mseconds *temp = (Ccs_mseconds *) from;
+
+	if (checkCcs((Ccs_seconds *) from) != RETURN_OK) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	to->year = (temp->yearMSB << 8) + temp->yearLSB;
+	to->hour = temp->hour;
+	to->minute = temp->minute;
+	to->second = temp->second;
+
+	if (*from & (1 << 3)) { //day of year variation
+		uint16_t tempDay = (temp->month << 8) + temp->day;
+		ReturnValue_t result = convertDaysOfYear(tempDay, to->year,
+				&(temp->month), &(temp->day));
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+
+	to->month = temp->month;
+	to->day = temp->day;
+
+	to->ticks = 0;
+	*foundLength = sizeof(Ccs_seconds);
+	if (subsecondsLength > 0) {
+		*foundLength += 1;
+		if (temp->secondEminus2 >= 100) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->ticks = temp->secondEminus2 * 10;
+	}
+
+	if (subsecondsLength > 1) {
+		*foundLength += 1;
+		if (temp->secondEminus4 >= 100) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->ticks += temp->secondEminus4 / 10;
+	}
+
+	return RETURN_OK;
+
+}
+
+ReturnValue_t CCSDSTime::convertFromASCII(TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	if (length < 19) {
+		return RETURN_FAILED;
+	}
+	uint16_t year;
+	uint8_t month;
+	uint16_t day;
+	uint8_t hour;
+	uint8_t minute;
+	float second;
+//try Code A (yyyy-mm-dd)
+	int count = sscanf((char *) from, "%4hi-%2hhi-%2hiT%2hhi:%2hhi:%fZ", &year,
+			&month, &day, &hour, &minute, &second);
+	if (count == 6) {
+		to->year = year;
+		to->month = month;
+		to->day = day;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->ticks = (second - floor(second)) * 1000;
+		return RETURN_OK;
+	}
+
+	//try Code B (yyyy-ddd)
+	count = sscanf((char *) from, "%4hi-%3hiT%2hhi:%2hhi:%fZ", &year, &day,
+			&hour, &minute, &second);
+	if (count == 5) {
+		uint8_t tempDay;
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
+				&month, &tempDay);
+		if (result != RETURN_OK) {
+			return RETURN_FAILED;
+		}
+		to->year = year;
+		to->month = month;
+		to->day = tempDay;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->ticks = (second - floor(second)) * 1000;
+		return RETURN_OK;
+	}
+
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::checkCcs(Ccs_seconds* time) {
+	if (time->pField & (1 << 3)) { //day of year variation
+		uint16_t day = (time->month << 8) + time->day;
+		if (day > 366) {
+			return INVALID_TIME_FORMAT;
+		}
+	} else {
+		if (time->month > 12) {
+			return INVALID_TIME_FORMAT;
+		}
+		if (time->day > 31) {
+			return INVALID_TIME_FORMAT;
+		}
+	}
+	if (time->hour > 23) {
+		return INVALID_TIME_FORMAT;
+	}
+	if (time->minute > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+	if (time->second > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertDaysOfYear(uint16_t dayofYear, uint16_t year,
+		uint8_t* month, uint8_t* day) {
+	if (isLeapYear(year)) {
+		if (dayofYear > 366) {
+			return INVALID_DAY_OF_YEAR;
+		}
+	} else {
+		if (dayofYear > 365) {
+			return INVALID_DAY_OF_YEAR;
+		}
+	}
+	*month = 1;
+	if (dayofYear <= 31) {
+		*day = dayofYear;
+		return RETURN_OK;
+	}
+	*month += 1;
+	dayofYear -= 31;
+	if (isLeapYear(year)) {
+		if (dayofYear <= 29) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 29;
+	} else {
+		if (dayofYear <= 28) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 28;
+	}
+	while (*month <= 12) {
+		if (dayofYear <= 31) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 31;
+
+		if (dayofYear <= 30) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 30;
+	}
+	return INVALID_DAY_OF_YEAR;
+}
+
+bool CCSDSTime::isLeapYear(uint16_t year) {
+	if ((year % 400) == 0) {
+		return true;
+	}
+	if ((year % 100) == 0) {
+		return false;
+	}
+	if ((year % 4) == 0) {
+		return true;
+	}
+	return false;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(CDS_short* to, const timeval* from) {
+	to->pField = (CDS << 4) + 0;
+	uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
+			+ DAYS_CCSDS_TO_UNIX_EPOCH;
+	if (days > (1 << 16)) {
+		//Date is beyond year 2137
+		return TIME_DOES_NOT_FIT_FORMAT;
+	}
+	to->dayMSB = (days & 0xFF00) >> 8;
+	to->dayLSB = (days & 0xFF);
+	uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
+			+ (from->tv_usec / 1000);
+	to->msDay_hh = (msDay & 0xFF000000) >> 24;
+	to->msDay_h = (msDay & 0xFF0000) >> 16;
+	to->msDay_l = (msDay & 0xFF00) >> 8;
+	to->msDay_ll = (msDay & 0xFF);
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
+	to->pFiled = (AGENCY_DEFINED << 4) + 5;
+	to->seconds_hh = (from->tv_sec >> 24) & 0xff;
+	to->seconds_h = (from->tv_sec >> 16) & 0xff;
+	to->seconds_l = (from->tv_sec >> 8) & 0xff;
+	to->seconds_ll = (from->tv_sec >> 0) & 0xff;
+
+	//convert the µs to 2E-16 seconds
+	uint64_t temp = from->tv_usec;
+	temp = temp << 16;
+	temp = temp / 1E6;
+
+	to->subsecondsMSB = (temp >> 8) & 0xff;
+	to->subsecondsLSB = temp & 0xff;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	//We don't expect ascii here.
+	uint8_t codeIdentification = (*from >> 4);
+	switch (codeIdentification) {
+	case CUC_LEVEL1:
+		return convertFromCUC(to, from, foundLength, maxLength);
+	case CDS:
+		return convertFromCDS(to, from, foundLength, maxLength);
+	case CCS:
+		return convertFromCCS(to, from, foundLength, maxLength);
+	default:
+		return UNSUPPORTED_TIME_FORMAT;
+	}
+
+
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	if (maxLength < 1) {
+		return INVALID_TIME_FORMAT;
+	}
+	uint8_t pField = *from;
+	from++;
+	ReturnValue_t result = convertFromCUC(to, pField, from, foundLength, maxLength-1 );
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		if (foundLength != NULL) {
+			*foundLength += 1;
+		}
+	}
+	return result;
+}
+
+ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(TimeOfDay_t* to,
+		timeval* from) {
+	//TODO: This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	uint8_t pField = *from;
+	from++;
+	//Check epoch
+	if (pField & 0b1000) {
+		return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
+	}
+	//Check length
+	uint8_t expectedLength = 7; //Including p-Field.
+	bool extendedDays = pField & 0b100;
+	if (extendedDays) {
+		expectedLength += 1;
+	}
+	if ((pField & 0b11) == 0b01) {
+		expectedLength += 2;
+	} else if ((pField & 0b11) == 0b10) {
+		expectedLength += 4;
+	}
+	if (foundLength != NULL) {
+		*foundLength = expectedLength;
+	}
+	if (expectedLength > maxLength) {
+		return LENGTH_MISMATCH;
+	}
+	//Check and count days
+	uint32_t days = 0;
+	if (extendedDays) {
+		days = (from[0] << 16) + (from[1] << 8) + from[2];
+		from +=3;
+	} else {
+		days = (from[0] << 8) + from[1];
+		from +=2;
+	}
+	//Move to POSIX epoch.
+	if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
+		return INVALID_TIME_FORMAT;
+	}
+	days -= DAYS_CCSDS_TO_UNIX_EPOCH;
+	to->tv_sec = days * SECONDS_PER_DAY;
+	uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8) + from[3];
+	from +=4;
+	to->tv_sec += (msDay / 1000);
+	to->tv_usec = (msDay%1000)*1000;
+	if ((pField & 0b11) == 0b01 ) {
+		uint16_t usecs = (from[0] << 16) + from[1];
+		from += 2;
+		if (usecs > 999) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->tv_usec += usecs;
+	} else if ((pField & 0b11) == 0b10 ) {
+		uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8) + from[3];
+		from += 4;
+		if (picosecs > 999999) {
+			return INVALID_TIME_FORMAT;
+		}
+		//Not very useful.
+		to->tv_usec += (picosecs / 1000);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
+		const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
+	uint32_t secs = 0;
+	uint32_t subSeconds = 0;
+	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
+	uint8_t nFine = (pField & 0b11);
+	uint32_t totalLength = nCoarse+nFine;
+	if (foundLength != NULL) {
+		*foundLength = totalLength;
+	}
+	if (totalLength > maxLength) {
+		return LENGTH_MISMATCH;
+	}
+	for (int count = 0; count < nCoarse; count++) {
+		secs += *from << ((nCoarse*8-8)*(1+count));
+		from++;
+	}
+	for (int count = 0; count < nFine; count++) {
+		subSeconds += *from << ((nFine*8-8)*(1+count));
+		from++;
+	}
+	//Move to POSIX epoch.
+	to->tv_sec = secs;
+	if (pField & 0b10000) {
+		//CCSDS-Epoch
+		to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
+	}
+	to->tv_usec =  subsecondsToMicroseconds(subSeconds);
+	return RETURN_OK;
+}
+
+uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
+	uint64_t temp = (uint64_t)subseconds * 1000000 / (1 << (sizeof(subseconds)*8));
+	return temp;
+}
+
+ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	TimeOfDay_t tempTime;
+	ReturnValue_t result = convertFromCCS(&tempTime,from, foundLength, maxLength);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	return OSAL::convertTimeOfDayToTimeval(&tempTime, to);
+
+}

timemanager/CCSDSTime.h

@@ -0,0 +1,234 @@
+/*
+ * CCSDSTimeHelper.h
+ *
+ *  Created on: 22.03.2013
+ *      Author: tod
+ */
+
+#ifndef CCSDSTIME_H_
+#define CCSDSTIME_H_
+
+#include <framework/osal/OSAL.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <stdint.h>
+
+bool operator<(const timeval& lhs, const timeval& rhs);
+bool operator==(const timeval& lhs, const timeval& rhs);
+/**
+ * static helper class for CCSDS Time Code Formats
+ *
+ * as described in CCSDS 301.0-B-3
+ *
+ * Still work in progress thus TODO finishme
+ */
+class CCSDSTime: public HasReturnvaluesIF {
+public:
+	/**
+	 * The Time code identifications, bits 4-6 in the P-Field
+	 */
+	enum TimeCodeIdentification {
+		CCS = 0b101,
+		CUC_LEVEL1 = 0b001,
+		CUC_LEVEL2 = 0b010,
+		CDS = 0b100,
+		AGENCY_DEFINED = 0b110
+	};
+	static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
+			+ 2;
+	static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
+			+ 2;
+	/**
+	 * Struct for CDS day-segmented format.
+	 */
+	struct CDS_short {
+		uint8_t pField;
+		uint8_t dayMSB;
+		uint8_t dayLSB;
+		uint8_t msDay_hh;
+		uint8_t msDay_h;
+		uint8_t msDay_l;
+		uint8_t msDay_ll;
+	};
+	/**
+	 * Struct for the CCS fromat in day of month variation with seconds resolution
+	 */
+	struct Ccs_seconds {
+		uint8_t pField;
+		uint8_t yearMSB;
+		uint8_t yearLSB;
+		uint8_t month;
+		uint8_t day;
+		uint8_t hour;
+		uint8_t minute;
+		uint8_t second;
+	};
+
+	/**
+	 * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
+	 */
+	struct Ccs_mseconds {
+		uint8_t pField;
+		uint8_t yearMSB;
+		uint8_t yearLSB;
+		uint8_t month;
+		uint8_t day;
+		uint8_t hour;
+		uint8_t minute;
+		uint8_t second;
+		uint8_t secondEminus2;
+		uint8_t secondEminus4;
+	};
+
+	struct OBT_FLP {
+		uint8_t pFiled;
+		uint8_t seconds_hh;
+		uint8_t seconds_h;
+		uint8_t seconds_l;
+		uint8_t seconds_ll;
+		uint8_t subsecondsMSB;
+		uint8_t subsecondsLSB;
+	};
+
+	struct TimevalLess {
+		bool operator()(const timeval& lhs, const timeval& rhs) const {
+			return (lhs < rhs);
+		}
+	};
+
+	static const uint8_t INTERFACE_ID = CCSDS_TIME_HELPER_CLASS;
+	static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
+			MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
+
+	/**
+	 * convert a TimeofDay struct to ccs with seconds resolution
+	 *
+	 * Assumes a valid TimeOfDay. TODO: maybe check it anyway?
+	 *
+	 * @param to pointer to a CCS struct
+	 * @param from pointer to a TimeOfDay Struct
+	 * @return
+	 * 		- @c RETURN_OK as it assumes a valid TimeOfDay
+	 */
+	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
+			TimeOfDay_t const *from);
+
+	/**
+	 * Converts to CDS format from timeval.
+	 * @param to pointer to the CDS struct to generate
+	 * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
+	 * @return
+	 * 		- @c RETURN_OK as it assumes a valid timeval.
+	 */
+	static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
+
+	static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
+	/**
+	 * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
+	 *
+	 * Assumes a valid TimeOfDay. TODO: maybe check it anyway?
+	 *
+	 * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
+	 *
+	 * @param to pointer to a CCS struct
+	 * @param from pointer to a TimeOfDay Struct
+	 * @return
+	 * 		- @c RETURN_OK as it assumes a valid TimeOfDay
+	 */
+	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
+			TimeOfDay_t const *from);
+
+	/**
+	 * TODO: can this be modified to recognize padding?
+	 * Tries to interpret a Level 1 CCSDS time code
+	 *
+	 * It assumes binary formats contain a valid P Field and recognizes the ASCII format
+	 * by the lack of one.
+	 *
+	 * @param to an empty TimeOfDay struct
+	 * @param from pointer to an CCSDS Time code
+	 * @param length length of the Time code
+	 * @return
+	 * 		- @c RETURN_OK if successful
+	 * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported TODO: the missing codes should be implemented...
+	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
+	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
+	 */
+	static ReturnValue_t convertFromCcsds(TimeOfDay_t *to, uint8_t const *from,
+			uint32_t length);
+
+	/**
+	 * not implemented yet
+	 *
+	 * @param to
+	 * @param from
+	 * @return
+	 */
+	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCUC(TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
+			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
+			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCDS(TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(TimeOfDay_t *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromASCII(TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
+private:
+	CCSDSTime();
+	virtual ~CCSDSTime();
+	/**
+	 * checks a ccs time struct for validity
+	 *
+	 * only checks year to second, subseconds must be checked elsewhere
+	 *
+	 * @param time pointer to an Ccs struct (should be cast to Ccs_seconds as subseconds are not checked. Cast is save as subseconds are at the end of the struct)
+	 * @return
+	 */
+	static ReturnValue_t checkCcs(Ccs_seconds *time);
+
+	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
+	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
+	static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
+	static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
+			* SECONDS_PER_DAY;
+	/**
+	 * @param dayofYear
+	 * @param year
+	 * @param month
+	 * @param day
+	 */
+	static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
+			uint8_t *month, uint8_t *day);
+
+	static bool isLeapYear(uint16_t year);
+	static ReturnValue_t convertTimevalToTimeOfDay(TimeOfDay_t* to,
+			timeval* from);
+};
+
+#endif /* CCSDSTIME_H_ */

timemanager/Countdown.cpp

@@ -0,0 +1,39 @@
+/**
+ * @file	Countdown.cpp
+ * @brief	This file defines the Countdown class.
+ * @date	21.03.2013
+ * @author	baetz
+ */
+
+
+#include <framework/timemanager/Countdown.h>
+
+Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) {
+}
+
+Countdown::~Countdown() {
+}
+
+ReturnValue_t Countdown::setTimeout(uint32_t miliseconds) {
+	ReturnValue_t return_value = OSAL::getUptime( &startTime );
+	timeout = miliseconds;
+	return return_value;
+}
+
+bool Countdown::hasTimedOut() const {
+	uint32_t current_time;
+	OSAL::getUptime( &current_time );
+	if ( uint32_t(current_time - startTime) >= timeout) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+bool Countdown::isBusy() const {
+	return !hasTimedOut();
+}
+
+ReturnValue_t Countdown::resetTimer() {
+	return setTimeout(timeout);
+}

timemanager/Countdown.h

@@ -0,0 +1,29 @@
+/**
+ * @file	Countdown.h
+ * @brief	This file defines the Countdown class.
+ * @date	21.03.2013
+ * @author	baetz
+ */
+
+#ifndef COUNTDOWN_H_
+#define COUNTDOWN_H_
+
+#include <framework/osal/OSAL.h>
+
+class Countdown {
+private:
+	uint32_t startTime;
+public:
+	uint32_t timeout;
+	Countdown(uint32_t initialTimeout = 0);
+	~Countdown();
+	ReturnValue_t setTimeout(uint32_t miliseconds);
+
+	bool hasTimedOut() const;
+
+	bool isBusy() const;
+
+	ReturnValue_t resetTimer(); //!< Use last set timeout value and restart timer.
+};
+
+#endif /* COUNTDOWN_H_ */

timemanager/ReceivesTimeInfoIF.h

@@ -0,0 +1,32 @@
+/**
+ * @file	ReceivesTimeInfoIF.h
+ * @brief	This file defines the ReceivesTimeInfoIF class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#ifndef RECEIVESTIMEINFOIF_H_
+#define RECEIVESTIMEINFOIF_H_
+
+#include <framework/osal/OSAL.h>
+/**
+ * This is a Interface for classes that receive timing information
+ * with the help of a dedicated message queue.
+ */
+class ReceivesTimeInfoIF {
+public:
+	/**
+	 * Returns the id of the queue which receives the timing information.
+	 * @return Queue id of the timing queue.
+	 */
+	virtual MessageQueueId_t getTimeReceptionQueue() = 0;
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~ReceivesTimeInfoIF() {
+	}
+
+};
+
+
+#endif /* RECEIVESTIMEINFOIF_H_ */

timemanager/TimeMessage.cpp

@@ -0,0 +1,30 @@
+/**
+ * @file	TimeMessage.cpp
+ * @brief	This file defines the TimeMessage class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#include <framework/timemanager/TimeMessage.h>
+
+TimeMessage::TimeMessage() {
+	this->messageSize += sizeof(timeval);
+}
+
+TimeMessage::TimeMessage(timeval setTime) {
+	memcpy (this->getData(), &setTime, sizeof(timeval));
+	this->messageSize += sizeof(timeval);
+}
+
+TimeMessage::~TimeMessage() {
+}
+
+timeval TimeMessage::getTime() {
+	timeval temp;
+	memcpy( &temp, this->getData(), sizeof(timeval));
+	return temp;
+}
+
+size_t TimeMessage::getMinimumMessageSize() {
+	return this->MAX_SIZE;
+}

timemanager/TimeMessage.h

@@ -0,0 +1,48 @@
+/**
+ * @file	TimeMessage.h
+ * @brief	This file defines the TimeMessage class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#ifndef TIMEMESSAGE_H_
+#define TIMEMESSAGE_H_
+
+#include <framework/ipc/MessageQueueMessage.h>
+
+class TimeMessage : public MessageQueueMessage {
+protected:
+	/**
+	 * @brief	This call always returns the same fixed size of the message.
+	 * @return	Returns HEADER_SIZE + \c sizeof(timeval).
+	 */
+	size_t getMinimumMessageSize();
+public:
+
+	/**
+	 * @ brief the size of a TimeMessage
+	 */
+	static const uint32_t MAX_SIZE = HEADER_SIZE + sizeof(timeval);
+
+	/**
+	 * @brief	In the default constructor, only the message_size is set.
+	 */
+	TimeMessage();
+	/**
+	 * @brief	With this constructor, the passed time information is directly put
+	 * 			into the message.
+	 * @param setTime The time information to put into the message.
+	 */
+	TimeMessage( timeval setTime );
+	/**
+	 * @brief	The class's destructor is empty.
+	 */
+	~TimeMessage();
+	/**
+	 * @brief	This getter returns the time information in timeval format.
+	 * @return	Returns the time stored in this packet.
+	 */
+	timeval getTime();
+};
+
+#endif /* TIMEMESSAGE_H_ */

timemanager/TimeStamperIF.h

@@ -0,0 +1,22 @@
+/*
+ * TimeStamperIF.h
+ *
+ *  Created on: 31.03.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+#define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+class TimeStamperIF {
+public:
+	static const uint8_t MISSION_TIMESTAMP_SIZE = 8; //!< This is a mission-specific constant and determines the total size reserved for timestamps.
+	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize) = 0;
+	virtual ~TimeStamperIF() {}
+};
+
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ */