updated unix udp bridge

globalfunctions/timevalOperations.cpp

@@ -1,92 +1,99 @@
-#include "timevalOperations.h"
+#include "timevalOperations.h"
-
+
-timeval& operator+=(timeval& lhs, const timeval& rhs) {
+timeval& operator+=(timeval& lhs, const timeval& rhs) {
-	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	sum += rhs.tv_sec * 1000000. + rhs.tv_usec;
+	sum += rhs.tv_sec * 1000000. + rhs.tv_usec;
-	lhs.tv_sec = sum / 1000000;
+	lhs.tv_sec = sum / 1000000;
-	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
+	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
-	return lhs;
+	return lhs;
-}
+}
-
+
-timeval operator+(timeval lhs, const timeval& rhs) {
+timeval operator+(timeval lhs, const timeval& rhs) {
-	lhs += rhs;
+	lhs += rhs;
-	return lhs;
+	return lhs;
-}
+}
-
+
-timeval& operator-=(timeval& lhs, const timeval& rhs) {
+timeval& operator-=(timeval& lhs, const timeval& rhs) {
-	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	sum -= rhs.tv_sec * 1000000. + rhs.tv_usec;
+	sum -= rhs.tv_sec * 1000000. + rhs.tv_usec;
-	lhs.tv_sec = sum / 1000000;
+	lhs.tv_sec = sum / 1000000;
-	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
+	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
-	return lhs;
+	return lhs;
-}
+}
-
+
-timeval operator-(timeval lhs, const timeval& rhs) {
+timeval operator-(timeval lhs, const timeval& rhs) {
-	lhs -= rhs;
+	lhs -= rhs;
-	return lhs;
+	return lhs;
-}
+}
-
+
-double operator/(const timeval& lhs, const timeval& rhs) {
+double operator/(const timeval& lhs, const timeval& rhs) {
-	double lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	double lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	double rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
+	double rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
-	return lhs64 / rhs64;
+	return lhs64 / rhs64;
-}
+}
-
+
-timeval& operator/=(timeval& lhs, double scalar) {
+timeval& operator/=(timeval& lhs, double scalar) {
-	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	product /= scalar;
+	product /= scalar;
-	lhs.tv_sec = product / 1000000;
+	lhs.tv_sec = product / 1000000;
-	lhs.tv_usec = product - lhs.tv_sec * 1000000;
+	lhs.tv_usec = product - lhs.tv_sec * 1000000;
-	return lhs;
+	return lhs;
-}
+}
-
+
-timeval operator/(timeval lhs, double scalar) {
+timeval operator/(timeval lhs, double scalar) {
-	lhs /= scalar;
+	lhs /= scalar;
-	return lhs;
+	return lhs;
-}
+}
-
+
-timeval& operator*=(timeval& lhs, double scalar) {
+timeval& operator*=(timeval& lhs, double scalar) {
-	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	product *= scalar;
+	product *= scalar;
-	lhs.tv_sec = product / 1000000;
+	lhs.tv_sec = product / 1000000;
-	lhs.tv_usec = product - lhs.tv_sec * 1000000;
+	lhs.tv_usec = product - lhs.tv_sec * 1000000;
-	return lhs;
+	return lhs;
-}
+}
-
+
-timeval operator*(timeval lhs, double scalar) {
+timeval operator*(timeval lhs, double scalar) {
-	lhs *= scalar;
+	lhs *= scalar;
-	return lhs;
+	return lhs;
-}
+}
-
+
-timeval operator*(double scalar, timeval rhs) {
+timeval operator*(double scalar, timeval rhs) {
-	rhs *= scalar;
+	rhs *= scalar;
-	return rhs;
+	return rhs;
-}
+}
-
+
-bool operator==(const timeval& lhs, const timeval& rhs) {
+bool operator==(const timeval& lhs, const timeval& rhs) {
-	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
+	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
-	return lhs64 == rhs64;
+	return lhs64 == rhs64;
-}
+}
-bool operator!=(const timeval& lhs, const timeval& rhs) {
+bool operator!=(const timeval& lhs, const timeval& rhs) {
-	return !operator==(lhs, rhs);
+	return !operator==(lhs, rhs);
-}
+}
-bool operator<(const timeval& lhs, const timeval& rhs) {
+bool operator<(const timeval& lhs, const timeval& rhs) {
-	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
+	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
-	return lhs64 < rhs64;
+	return lhs64 < rhs64;
-}
+}
-bool operator>(const timeval& lhs, const timeval& rhs) {
+bool operator>(const timeval& lhs, const timeval& rhs) {
-	return operator<(rhs, lhs);
+	return operator<(rhs, lhs);
-}
+}
-bool operator<=(const timeval& lhs, const timeval& rhs) {
+bool operator<=(const timeval& lhs, const timeval& rhs) {
-	return !operator>(lhs, rhs);
+	return !operator>(lhs, rhs);
-}
+}
-bool operator>=(const timeval& lhs, const timeval& rhs) {
+bool operator>=(const timeval& lhs, const timeval& rhs) {
-	return !operator<(lhs, rhs);
+	return !operator<(lhs, rhs);
-}
+}
-
+
-double timevalOperations::toDouble(const timeval timeval) {
+double timevalOperations::toDouble(const timeval timeval) {
-	double result = timeval.tv_sec * 1000000. + timeval.tv_usec;
+	double result = timeval.tv_sec * 1000000. + timeval.tv_usec;
-	return result / 1000000.;
+	return result / 1000000.;
-}
+}
+
+timeval timevalOperations::toTimeval(const double seconds) {
+	timeval tval;
+	tval.tv_sec = seconds;
+	tval.tv_usec = seconds *(double) 1e6 - (tval.tv_sec *1e6);
+	return tval;
+}

globalfunctions/timevalOperations.h

@@ -41,6 +41,7 @@ namespace timevalOperations {
  * @return seconds
  */
 double toDouble(const timeval timeval);
+timeval toTimeval(const double seconds);
 }
 
 #endif /* TIMEVALOPERATIONS_H_ */

osal/linux/TcUnixUdpPollingTask.cpp

@@ -1,5 +1,5 @@
-#include <framework/osal/linux/TcUnixUdpPollingTask.h>
+#include "TcUnixUdpPollingTask.h"
-#include <framework/globalfunctions/arrayprinter.h>
+#include "../../globalfunctions/arrayprinter.h"
 
 TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,

osal/linux/TcUnixUdpPollingTask.h

@@ -1,9 +1,9 @@
 #ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
 #define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
 
-#include <framework/objectmanager/SystemObject.h>
+#include "../../objectmanager/SystemObject.h"
-#include <framework/osal/linux/TmTcUnixUdpBridge.h>
+#include "../../osal/linux/TmTcUnixUdpBridge.h"
-#include <framework/tasks/ExecutableObjectIF.h>
+#include "../../tasks/ExecutableObjectIF.h"
 
 #include <sys/socket.h>
 #include <vector>

osal/linux/TmTcUnixUdpBridge.cpp

@@ -1,6 +1,6 @@
-#include <framework/osal/linux/TmTcUnixUdpBridge.h>
+#include "TmTcUnixUdpBridge.h"
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include <framework/ipc/MutexHelper.h>
+#include "../../ipc/MutexHelper.h"
 
 #include <errno.h>
 #include <arpa/inet.h>
@@ -85,7 +85,7 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 }
 
 void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
-	MutexHelper lock(mutex, 10);
+	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //	char ipAddress [15];
 //	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,

osal/linux/TmTcUnixUdpBridge.h

@@ -1,8 +1,8 @@
 #ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
 #define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
 
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
+#include "../../tmtcservices/AcceptsTelecommandsIF.h"
-#include <framework/tmtcservices/TmTcBridge.h>
+#include "../../tmtcservices/TmTcBridge.h"
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netinet/udp.h>