added C++ embedded part

2015/ppc/.gitignore

@@ -0,0 +1 @@
+gps/UnitTest

2015/ppc/.ruby-gemset

@@ -0,0 +1 @@
+inga

2015/ppc/.ruby-version

@@ -0,0 +1 @@
+2.1

2015/ppc/README.mkd

@@ -0,0 +1,79 @@
+
+# GPS on CAN
+
+In this task you will need to receive Can-frames on the can-bus that contain the GPS location of the
+vehicle. The raw data has to be converted to arc-milliseconds
+
+    1°2'5" == (1*3600+ 2*60 + 5)*1000
+
+Beware that the system you are running your code on will not support floating point operations.
+Use only unsigned and signed integers!
+Still the precision of your calculations has to be +-100 milli-arc-seconds
+
+
+## Conversion to Arc-Degree
+
+inDegree hex = 180/(2^31-1) * (hex) [°]
+
+## GPS Datalayout in CAN Message
+
+		Byte7 ST_LAT_NAVI
+		Byte6 ST_LAT_NAVI
+		Byte5 ST_LAT_NAVI
+		Byte4 ST_LAT_NAVI
+		Byte3 ST_LONG_NAVI
+		Byte2 ST_LONG_NAVI
+		Byte1 ST_LONG_NAVI
+		Byte0 ST_LONG_NAVI
+
+## Byteorder
+
+Little Endian (Least Significant Byte is at lowest address)
+
+## Status Longitude Navigation
+
+		ST_LONG_NAVI
+
+### Possible Values
+
+		-180° ...  +180°
+
+### signal type
+
+32 Bit Signed Integer (Byte 0 ... Byte 3)
+
+### Invalid Data
+
+Invalid-Value: 80 00 00 00h
+Signal not available value: 7F FF FF FF
+
+## Status Latitude Navigation
+
+		ST_LAT_NAVI
+
+### Possible Values
+
+		-180° ...  +180°
+
+### signal type
+
+32 Bit Signed Integer (Byte 4 ... Byte 7)
+
+### Invalid Data
+
+Invalid-Value: 80 00 00 00h
+Signal not available value: 7F FF FF FF
+
+## Running the tests
+
+you will need a working ruby installation to execute the tests
+
+### Install the bake tool
+
+see https://esrlabs.com/gems/doc/bake-toolkit/
+
+
+### run the tests
+
+execute `rake run` from this directory
+

2015/ppc/common/include/commonTypes.h

@@ -0,0 +1,32 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+#ifndef COMMON_TYPES_H
+#define COMMON_TYPES_H
+
+/* standard types file to be used for
+ * all C++ basic software components */
+
+#ifdef UNIT_TEST
+
+typedef unsigned char       		uint8;
+typedef unsigned short        		uint16;
+typedef unsigned int        		uint32;
+typedef unsigned long long int      uint64;
+
+typedef signed char       			sint8;
+typedef signed short        		sint16;
+typedef signed int        			sint32;
+typedef signed long long int      	sint64;
+
+#else
+#include "Std_Types.h"
+
+typedef volatile uint32           	vuint32;
+typedef volatile uint32           	vuint32_t;
+#endif
+
+#endif /* COMMON_TYPES_H */

2015/ppc/common/include/util/CompileTimeConstraints.h

@@ -0,0 +1,92 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+#ifndef COMPILETIMECONSTRAINTS_H_
+#define COMPILETIMECONSTRAINTS_H_
+
+#include "commonTypes.h"
+
+#define ZGW_JOIN( X, Y ) ZGW_DO_JOIN( X, Y )
+#define ZGW_DO_JOIN( X, Y ) ZGW_DO_JOIN2(X,Y)
+#define ZGW_DO_JOIN2( X, Y ) X##Y
+
+namespace common
+{
+template <bool x> struct STATIC_ASSERTION_FAILURE;
+template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
+
+# define ECU_STATIC_ASSERT( B ) \
+    typedef char ZGW_JOIN(zgw_static_assert_typedef_, __LINE__) \
+        [ ::common::STATIC_ASSERTION_FAILURE< (bool)( B ) >::value ]
+
+template<bool Condition>
+struct CompileTimeError;
+
+template<>
+struct CompileTimeError<false> {};
+
+/**
+ * STATIC_CHECK will fail when expr evaluates to true
+ */
+#define STATIC_CHECK(msg, expr) \
+    { common::CompileTimeError<(expr)> ERROR_##msg; (void)ERROR_##msg; }
+
+/**
+ * STATIC_ASSERT will fail when expr evaluates to false
+ * simple usage: STATIC_ASSERT(too_bad_static_assert_failed, 2 > 3)
+ */
+#define STATIC_ASSERT(msg, expr) \
+    { common::CompileTimeError<!(expr)> ERROR_##msg; (void)ERROR_##msg; }
+
+/**
+ * another example-setup for compile-time-check: a class only has to inherit from this constraint,
+ * so the constructor of this Constraint has to be compiled and the static check is executed
+ * by the compiler.
+ * will only compile if ACTUAL_SIZE <= ALLOWED_SIZE
+ *
+ * the argument passed to the STATIC_CHECK-macro can be any allowed C++-identifier,
+ */
+template<uint32 ACTUAL_SIZE, uint32 ALLOWED_SIZE>
+struct ValidSizeConstraint
+{
+   	static void constraint()
+   	{
+   		STATIC_CHECK(fuck_allowed_size_is_too_small,
+   					(ACTUAL_SIZE > ALLOWED_SIZE));
+   	}
+   	ValidSizeConstraint()
+   	{
+      	void (*p)() = constraint;
+      	(*p)();//call function, only to make compiler warning about unused variable go away, will get optimized away
+  	}
+};
+
+/**
+ * static checks
+ * usage:
+ * struct B {}; struct D : B { };
+ * ...Derived_from<D,B>();
+ */
+template<class T, class B> struct Derived_from
+{
+	static void constraints(T* p) { B* pb = p; pb = pb;}
+	Derived_from() { void(*p)(T*) = constraints; p = p;}
+};
+
+template<class T1, class T2> struct Can_copy
+{
+	static void constraints(T1 a, T2 b) { T2 c = a; b = a; c = a; b = a; }
+	Can_copy() { void(*p)(T1,T2) = constraints;}
+};
+
+template<class T1, class T2 = T1> struct Can_compare
+{
+	static void constraints(T1 a, T2 b) { a==b; a!=b; a<b; }
+	Can_compare() { void(*p)(T1,T2) = constraints;}
+};
+}//namespace common
+
+#endif /*COMPILETIMECONSTRAINTS_H_*/

2015/ppc/common/include/util/SAlgorithm.h

@@ -0,0 +1,175 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+/**
+ * Contains STL like algorithms.
+ * \file	SAlgorithm.h
+ * \ingroup	sstl
+ */
+#ifndef SALGORITHM_H_
+#define SALGORITHM_H_
+
+#include "SIteratorBaseTypes.h"
+
+/**
+ * returns minimum of two values
+ * \param	T	type of values
+ * \param	t1	first value
+ * \param	t2	second value
+ * \return	minimum of t1 and t2
+ */
+template<typename T>
+inline const T& smin(const T& t1, const T& t2)
+{
+	return (t1 < t2 ? t1 : t2);
+}
+
+/**
+ * returns maximum of two values
+ * \param	T	type of values
+ * \param	t1	first value
+ * \param	t2	second value
+ * \return	maximum of t1 and t2
+ */
+template<typename T>
+inline const T& smax(const T& t1, const T& t2)
+{
+	return (t1 > t2 ? t1 : t2);
+}
+
+/**
+ * swaps two values
+ * \param	T	type of values
+ * \param	t1	first value
+ * \param	t2	second value
+ */
+template<typename T>
+inline void sswap(T& t1, T& t2)
+{
+	T t = t1;
+	t1 = t2;
+	t2 = t;
+}
+
+/**
+ * finds a value in a given iterator range
+ * \param	InputIterator		type of iterators
+ * \param	EqualityCompareable	type of value to find
+ * \param	first	begin of range
+ * \param	last	and of range
+ * \param	value	value to find in range
+ * \return	iterator to first element equal to value in range
+ */
+template<
+	typename InputIterator,
+	typename EqualityCompareable>
+inline InputIterator sfind(
+	InputIterator first,
+	InputIterator last,
+	const EqualityCompareable& value)
+{
+	return sfind(
+		first,
+		last,
+		value,
+		typename SIteratorTraits<InputIterator>::iterator_category());
+}
+
+/**
+ * implementation of sfind for input iterators
+ * \see		sfind()
+ */
+template<
+	typename InputIterator,
+	typename EqualityCompareable>
+inline InputIterator sfind(
+	InputIterator first,
+	InputIterator last,
+	const EqualityCompareable& value,
+	SInputIteratorTag)
+{
+	while (!(first == last) && !(*first == value))
+	{
+		++first;
+	}
+	return first;
+}
+
+/**
+ * removes all elements equal to a value from a range and copies it to another
+ * \param	InputIterator		type of input range iterators
+ * \param	OutputIterator		type of result range iterator
+ * \param	EqualityCompareable	type of value to remove from input range
+ * \param	first	begin of input range
+ * \param	last	end of input range
+ * \param	result	begin iterator of result range
+ * \param	value	value to remove
+ * \return	end of result range
+ */
+template<
+	typename InputIterator,
+	typename OutputIterator,
+	typename EqualityCompareable>
+inline OutputIterator sremove_copy(
+	InputIterator first,
+	InputIterator last,
+	OutputIterator result,
+	const EqualityCompareable& value)
+{
+	while (first != last)
+	{
+		if (!(*first == value))
+		{
+			*result = *first;
+			++result;
+		}
+		++first;
+	}
+	return result;
+}
+
+/**
+ * removes all elements of a given value from a range
+ * \param	ForwardIterator		type of range iterator
+ * \param	EqualityCompareable	type of value to remove
+ * \param	first	begin of range
+ * \param	last	end of range
+ * \param	value	value to remove from range
+ * \return	iterator to result range
+ */
+template<
+	typename ForwardIterator,
+	typename EqualityCompareable>
+ForwardIterator sremove(
+	ForwardIterator first,
+	ForwardIterator last,
+	const EqualityCompareable& value)
+{
+  first = sfind(first, last, value);
+  ForwardIterator i = first;
+  return first == last ? first : sremove_copy(++i, last, first, value);
+}
+
+template<
+	typename InputIterator,
+	typename EqualityComparable>
+typename SIteratorTraits<InputIterator>::difference_type scount(
+	InputIterator first, InputIterator last,
+	const EqualityComparable& value)
+{
+	typename SIteratorTraits<InputIterator>::difference_type result = 0;
+	while (first != last)
+	{
+		if (*first == value)
+		{
+			++result;
+		}
+		++first;
+	}
+	return result;
+}
+
+#endif /*SALGORITHM_H_*/

2015/ppc/common/include/util/SBaseTypes.h

@@ -0,0 +1,38 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+/**
+ * Contains basic type traits.
+ * \file	SBaseTypes.h
+ * \ingroup	sstl
+ */
+#ifndef SBASETYPES_H_
+#define SBASETYPES_H_
+
+/**
+ * type traits
+ * \param	T	type to get traits from
+ *
+ * This class may be used to save some type work.
+ */
+template<typename T>
+struct STypeTraits
+{
+	/** unsigned integral type */
+	typedef unsigned int	size_type;
+	/** signed integral type */
+	typedef signed int		difference_type;
+	/** type of T itsself */
+	typedef T				value_type;
+	/** pointer to T */
+	typedef T*				pointer;
+	/** reference to T */
+	typedef T&				reference;
+	/** const reference to T */
+	typedef const T&		const_reference;
+};
+
+#endif /*SBASETYPES_H_*/

2015/ppc/common/include/util/SIteratorBaseTypes.h

@@ -0,0 +1,141 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+/**
+ * Contains base types for iterators.
+ * \file	SIteratorBaseTypes.h
+ * \ingroup	sstl
+ */
+#ifndef SITERATORBASETYPES_H_
+#define SITERATORBASETYPES_H_
+
+/**
+ * input iterator
+ *
+ * \section	Description
+ * May advance through a iterator range. Reads each
+ * value exactly one time.
+ */
+struct SInputIteratorTag {};
+
+/**
+ * output iterator
+ *
+ * \section	Description
+ * May advance through a iterator range and alter values.
+ */
+struct SOutputIteratorTag {};
+
+/**
+ * forward iterator
+ *
+ * \section	Description
+ * May advance through a iterator range and read each value
+ * more than on time.
+ */
+struct SForwardIteratorTag : public SInputIteratorTag {};
+
+/**
+ * bidirectional iterator
+ *
+ * \section	Description
+ * May go through a iterator range in both directions and
+ * read each value more than one time
+ */
+struct SBidirectionalIteratorTag : public SForwardIteratorTag {};
+
+/**
+ * random access iterator
+ *
+ * \section	Description
+ * May go through a iterator range like a pointer through an
+ * array and read each value more than one time.
+ */
+struct SRandomAccessIteratorTag : public SBidirectionalIteratorTag {};
+
+/**
+ * optional base class for iterators
+ * \param	Category	iterators category
+ * \param	T			type iterator points to
+ * \param	Distance	signed integral type
+ * \param	Pointer		pointer to T
+ * \param	Reference	reference to T
+ *
+ * Classes may subclass this class to save some typedef work.
+ */
+template<
+	typename Category,
+	typename T,
+	typename Distance = signed int,
+	typename Pointer = T*,
+	typename Reference = T&>
+struct SIterator
+{
+	/** the iterators category */
+	typedef Category	iterator_category;
+	/** type of value iterator points to */
+	typedef T			value_type;
+	/** signed integral type */
+	typedef Distance	difference_type;
+	/** pointer to value type */
+	typedef Pointer		pointer;
+	/** reference to value type */
+	typedef Reference	reference;
+};
+
+/**
+ * traits for iterators
+ * \param	Iterator	iterator to generate traits for
+ */
+template<typename Iterator>
+struct SIteratorTraits
+{
+	/** the iterators category */
+	typedef typename Iterator::iterator_category	iterator_category;
+	/** type of value iterator points to */
+	typedef typename Iterator::value_type			value_type;
+	/** signed integral type */
+	typedef typename Iterator::difference_type		difference_type;
+	/** pointer to value */
+	typedef typename Iterator::pointer				pointer;
+	/** reference to value */
+	typedef typename Iterator::reference			reference;
+};
+
+/**
+ * special implementation for pointers
+ * \param	T	type of value for whose pointer traits are generated
+ *
+ * \see		SIteratorTraits
+ */
+template<typename T>
+struct SIteratorTraits<T*>
+{
+	typedef SRandomAccessIteratorTag 	iterator_category;
+	typedef T							value_type;
+	typedef signed int					difference_type;
+	typedef value_type*					pointer;
+	typedef value_type&					reference;
+};
+
+/**
+ * special implementation for const pointers
+ * \param	T	type of value for whose const pointer traits are generated
+ *
+ * \see		SIteratorTraits
+ *
+ */
+template<typename T>
+struct SIteratorTraits<const T*>
+{
+	typedef SRandomAccessIteratorTag 	iterator_category;
+	typedef T							value_type;
+	typedef signed int					difference_type;
+	typedef const value_type*			pointer;
+	typedef const value_type&			reference;
+};
+
+#endif /*SITERATORBASETYPES_H_*/

2015/ppc/common/include/util/SLinkedListSet.h

@@ -0,0 +1,441 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+#ifndef SLINKEDLIST_H_
+#define SLINKEDLIST_H_
+
+#include "util/SBaseTypes.h"
+#include "util/SIteratorBaseTypes.h"
+#include "util/CompileTimeConstraints.h"
+#include <cassert>
+
+template<typename T>
+class SLinkedListSetNode
+{
+public:
+
+	typedef T value_type;
+	SLinkedListSetNode() :
+		fpNext(0L),
+		fAddedToList(false)
+	{}
+
+	T* getNext() const
+	{
+		return fpNext;
+	}
+
+	void setNext(T* pNext)
+	{
+		fpNext = pNext;
+	}
+
+	void addToList()
+	{
+		assert(!fAddedToList);
+		fAddedToList = true;
+	}
+
+	void removeFromList()
+	{
+		fAddedToList = false;
+	}
+private:
+	SLinkedListSetNode(const SLinkedListSetNode&);
+	SLinkedListSetNode& operator=(const SLinkedListSetNode&);
+
+	T* fpNext;
+	bool fAddedToList;
+};
+
+template<typename T>
+class SLinkedListSetIterator;
+
+template<typename T>
+class SLinkedListSet
+	:	common::Derived_from<T, SLinkedListSetNode<T> >
+{
+private:
+	/** type of list itsself */
+	typedef SLinkedListSet<T>							self_type;
+public:
+	/** type of values stored in vector */
+	typedef typename STypeTraits<T>::value_type			value_type;
+	/** pointer to value */
+	typedef typename STypeTraits<T>::pointer			pointer;
+	/** reference to value */
+	typedef typename STypeTraits<T>::reference			reference;
+	/** const reference to value */
+	typedef typename STypeTraits<T>::const_reference	const_reference;
+	/** unsigned integral type */
+	typedef typename STypeTraits<T>::size_type			size_type;
+	/** signed integral type */
+	typedef typename STypeTraits<T>::difference_type	difference_type;
+	/** iterator type */
+	typedef SLinkedListSetIterator<T>					iterator;
+	/** const iterator type */
+	typedef SLinkedListSetIterator<const T>				const_iterator;
+
+	SLinkedListSet() :
+		fpFirst(0L),
+		fpLast(0L)
+	{
+		clear();
+	}
+
+	/**
+	 * @note
+	 * O(n)!
+	 * @todo
+	 * Maybe a field would be better
+	 */
+	size_type size() const
+	{
+		size_type size = (fpFirst) ? 1 : 0;
+		for (const T* pNode = fpFirst; pNode != fpLast; pNode = pNode->getNext())
+		{
+			++size;
+		}
+		return size;
+	}
+
+	bool empty() const
+	{
+		return (fpFirst == 0L);
+	}
+
+	void clear()
+	{
+		while (!empty())
+		{
+			pop_front();
+		}
+		fpFirst = 0L;
+		fpLast = 0L;
+	}
+
+	const_reference front() const
+	{
+		assert(fpFirst);
+		return *fpFirst;
+	}
+
+	reference front()
+	{
+		return const_cast<reference>(
+				static_cast<const self_type&>(
+					*this).front());
+	}
+
+	const_reference back() const
+	{
+		assert(fpLast);
+		return *fpLast;
+	}
+
+	reference back()
+	{
+		return const_cast<reference>(
+				static_cast<const self_type&>(
+					*this).back());
+	}
+
+	void push_front(T& node)
+	{
+		if (contains_node(&node))
+		{
+			return;
+		}
+		node.addToList();
+		node.setNext(fpFirst);
+		fpFirst = &node;
+		if (!fpLast)
+		{//inserted first node
+			fpLast = fpFirst;
+			fpFirst->setNext(0L);
+		}
+	}
+
+	void push_back(T& node)
+	{
+		if (empty())
+		{//inserted first node
+			fpFirst = &node;
+		}
+		else
+		{
+			if (contains_node(&node))
+			{
+				return;
+			}
+			fpLast->setNext(&node);
+		}
+		node.addToList();
+		fpLast = &node;
+		fpLast->setNext(0L);
+	}
+
+	void pop_front()
+	{
+		if (!fpFirst)
+		{
+			return;
+		}
+		fpFirst->removeFromList();
+		fpFirst = fpFirst->getNext();
+		if (!fpFirst)
+		{//removed last element
+			fpLast = 0L;
+		}
+	}
+
+	void pop_back();
+
+	iterator begin()
+	{
+		return iterator(fpFirst);
+	}
+
+	const_iterator begin() const
+	{
+		return const_iterator(fpFirst);
+	}
+
+	iterator end()
+	{
+		return iterator(0L);
+	}
+
+	const_iterator end() const
+	{
+		return const_iterator(0L);
+	}
+
+	iterator erase(iterator pos);
+
+	iterator insert(iterator pos, T& value);
+
+	void remove(const T& value);
+
+	bool contains(const T& value) const
+	{
+		return contains_node(&value);
+	}
+private:
+	SLinkedListSet(const SLinkedListSet&);
+	SLinkedListSet& operator=(const SLinkedListSet&);
+
+	T* findPredecessor(const T* pNode) const
+	{
+		T* pResult = fpFirst;
+		while ((pResult != 0L) && (pResult->getNext() != pNode))
+		{
+			pResult = pResult->getNext();
+		}
+		return pResult;
+	}
+
+	bool contains_node(const T* pNodeToFind) const;
+
+	T*	fpFirst;
+	T*	fpLast;
+};
+
+template<typename T>
+bool SLinkedListSet<T>::contains_node(const T* pNodeToFind) const
+{
+	T* pNode = fpFirst;
+	while (pNode != 0L)
+	{
+		if (pNodeToFind == pNode)
+		{
+			return true;
+		}
+		pNode = pNode->getNext();
+	}
+	return false;
+}
+
+template<typename T>
+void SLinkedListSet<T>::pop_back()
+{
+	if (!fpLast)
+	{
+		return;
+	}
+	fpLast->removeFromList();
+	if (fpFirst == fpLast)
+	{
+		clear();
+	}
+	else
+	{
+		fpLast = findPredecessor(fpLast);
+		assert(fpLast);
+		fpLast->setNext(0L);
+	}
+}
+
+template<typename T>
+typename SLinkedListSet<T>::iterator SLinkedListSet<T>::erase(
+	SLinkedListSet<T>::iterator pos)
+{
+	if (!fpFirst)
+	{
+		return end();
+	}
+	iterator next = pos;
+	++next;
+	if (pos == begin())
+	{//remove first element
+		pop_front();
+	}
+	else
+	{
+		pos->removeFromList();
+		T* pNode = findPredecessor(pos.operator->());
+		assert(pNode);
+		if (pNode->getNext() == fpLast)
+		{//removing last element
+			fpLast = pNode;
+		}
+		pNode->setNext(pos->getNext());
+	}
+	return next;
+}
+
+template<typename T>
+typename SLinkedListSet<T>::iterator SLinkedListSet<T>::insert(
+	SLinkedListSet<T>::iterator pos,
+	T& value)
+{
+	if (contains_node(&value))
+	{
+		return pos;
+	}
+	if (empty() || (pos == begin()))
+	{
+		push_front(value);
+	}
+	else if (pos == end())
+	{
+		push_back(value);
+	}
+	else
+	{
+		value.addToList();
+		T* pNode = findPredecessor(pos.operator->());
+		assert(pNode);
+		value.setNext(pNode->getNext());
+		pNode->setNext(&value);
+	}
+	return iterator(&value);
+}
+
+template<typename T>
+void SLinkedListSet<T>::remove(const T& value)
+{
+	if (&value == fpFirst)
+	{
+		pop_front();
+	}
+	else if (&value == fpLast)
+	{
+		pop_back();
+	}
+	else
+	{
+		const_cast<T&>(value).removeFromList();
+		T* pNode = findPredecessor(&value);
+		if (pNode)
+		{
+			pNode->setNext(value.getNext());
+		}
+	}
+}
+
+template <typename T>
+bool operator==(
+	const SLinkedListSetIterator<T>& x,
+	const SLinkedListSetIterator<T>& y);
+
+template <typename T>
+bool operator!=(
+	const SLinkedListSetIterator<T>& x,
+	const SLinkedListSetIterator<T>& y);
+
+template<typename T>
+class SLinkedListSetIterator
+{
+public:
+	/** the iterators category */
+	typedef SForwardIteratorTag							iterator_category;
+	/** value type of iterator */
+	typedef typename STypeTraits<T>::value_type			value_type;
+	/** reference to value */
+	typedef typename STypeTraits<T>::reference			reference;
+	/** pointer to value */
+	typedef typename STypeTraits<T>::pointer			pointer;
+	/** signed integral type */
+	typedef typename STypeTraits<T>::difference_type	difference_type;
+
+	SLinkedListSetIterator(T* pValue) :
+		fpValue(pValue)
+	{}
+
+	SLinkedListSetIterator(const SLinkedListSetIterator& rhs) :
+		fpValue(rhs.fpValue)
+	{}
+
+	SLinkedListSetIterator& operator=(const SLinkedListSetIterator& rhs)
+	{
+		fpValue = rhs.fpValue;
+		return *this;
+	}
+
+	SLinkedListSetIterator& operator++()
+	{
+		fpValue = fpValue->getNext();
+		return *this;
+	}
+
+	reference operator*()
+	{
+		return *fpValue;
+	}
+
+	pointer operator->()
+	{
+		return fpValue;
+	}
+
+private:
+	friend bool operator==<T>(
+		const SLinkedListSetIterator<T>&,
+		const SLinkedListSetIterator<T>&);
+	friend bool operator!=<T>(
+		const SLinkedListSetIterator<T>&,
+		const SLinkedListSetIterator<T>&);
+	T* fpValue;
+};
+
+template<typename T>
+inline bool operator==(
+	const SLinkedListSetIterator<T>& x,
+	const SLinkedListSetIterator<T>& y)
+{
+	return (x.fpValue == y.fpValue);
+}
+
+template<typename T>
+inline bool operator!=(
+	const SLinkedListSetIterator<T>& x,
+	const SLinkedListSetIterator<T>& y)
+{
+	return !(x == y);
+}
+
+#endif /*SLINKEDLIST_H_*/

2015/ppc/common/include/util/Uncopyable.h

@@ -0,0 +1,57 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+/**
+ * Contains helpers to make C++ classes uncopyable, i.e. declare copy
+ * constructor and assignment operator private.
+ * \file	Uncopyable.h
+ */
+#ifndef UNCOPYABLE_H_
+#define UNCOPYABLE_H_
+
+/**
+ * The macro MAKE_UNCOPYABLE expands to a declaration of copy constructor and
+ * assignment operator.
+ * \par	Usage example
+ * \code
+ * class MyClass
+ * {
+ * 		MAKE_UNCOPYABLE(MyClass)
+ * public:
+ *		//...
+ * };
+ * \endcode
+ */
+#ifdef MAKE_UNCOPYABLE
+#error "MAKE_UNCOPYABLE was already defined!"
+#endif
+// PRQA S 1030 3
+#define MAKE_UNCOPYABLE(TypeName)		\
+	TypeName(const TypeName&);			\
+	TypeName& operator=(const TypeName&);
+
+namespace common
+{
+
+/**
+ * Inheriting from Uncopyable makes sure that no copies of any subclass
+ * are instantiated accidently because the C++ compiler will raise an error.
+ *
+ * \author	oliver.mueller
+ */
+class Uncopyable
+{
+protected:
+	Uncopyable(){}
+
+private:
+	Uncopyable(const Uncopyable&);
+	Uncopyable& operator=(const Uncopyable&);
+};
+
+}//namespace common
+
+#endif /*UNCOPYABLE_H_*/

2015/ppc/gps/Project.meta

@@ -0,0 +1,24 @@
+Project {
+  ExecutableConfig UnitTest {
+    Files "src/**/*.cpp"
+    ExcludeFiles "src/ac/*.cpp"
+    Files "test/**/*.cpp"
+    IncludeDir "include"
+    IncludeDir "test/include"
+    IncludeDir "common/include"
+    ArtifactName "gpsTests.exe"
+    PostSteps {
+      CommandLine "$(OutputDir)/$(ArtifactName) -r xml --out $(OutputDir)/test_$(ArtifactName).xml", filter: run, default: off
+    }
+    DefaultToolchain GCC {
+      Compiler CPP {
+        Flags "-g -Wall -fpermissive -fmessage-length=0"
+        Define "UNIT_TEST"
+      }
+      Compiler C {
+        Flags "-g -Wall -fpermissive -fmessage-length=0"
+        Define "UNIT_TEST"
+      }
+    }
+  }
+}

2015/ppc/gps/include/ac/GpsACPusher.h

@@ -0,0 +1,36 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+#ifndef AC_PUSHER_H_
+#define AC_PUSHER_H_
+
+#include "gps/IACPusher.h"
+
+namespace android
+{
+class ICaimTransceiver;
+}
+
+namespace gps
+{
+class GpsAcPusher : public IACPusher
+{
+public:
+	virtual void pushGPSCoordinates(sint32 latMs, sint32 longMs);
+private:
+	uint8 fPosition[15];
+	ICaimTransceiver& fCaimTransceiver;
+	static const uint8 LONGITUDE_OFFSET 							= 0;
+	static const uint8 LATITUDE_OFFSET 								= 4;
+	static const uint8 HEADING_OFFSET 								= 8;
+
+	static const uint8 HEIGHT_OFFSET 								= 9;
+	static const uint8 QUALITY_OFFSET 								= 11;
+	static const uint8 SPEED_OFFSET 								= 13;
+};
+} // namespace gps
+
+#endif /* end of include guard */
+

2015/ppc/gps/include/ac/IGpsACPusher.h

@@ -0,0 +1,21 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+#ifndef IAC_PUSHER_H_
+#define IAC_PUSHER_H_
+
+#include "commonTypes.h"
+
+namespace gps
+{
+class IGpsACPusher
+{
+public:
+	virtual void pushGPSCoordinates(sint32 latMs, sint32 longMs) = 0;
+
+};
+} // namespace gps
+#endif /* end of include guard */
+

2015/ppc/gps/include/busId/BusId.h

@@ -0,0 +1,236 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+#ifndef BUSID_H_
+#define BUSID_H_
+
+#include "commonTypes.h"
+#include "util/Uncopyable.h"
+
+//forward declarations
+class BusIdIterator;
+
+/**
+ * Abstraction for bus ids used throughout the system.
+ * @author	matthias.kessler
+ *
+ * BusId contains constants for all busses used and provides an iterator
+ * to access them. Each BusId will have an index that is unique in the system.
+ */
+class BusId
+{
+public:
+	enum { MAX_INDEX = 4 };
+	/** iterator over BusIds */
+	typedef BusIdIterator	iterator;
+	/** maximum number of busses, used to allocate static memory */
+	static const uint8	MAX_NUMBER_OF_BUSSES 	= MAX_INDEX;
+	static const uint8	NUMBER_OF_LIN_BUSSES 	= 1;
+
+	static const BusId 	BODYCAN;
+	static const BusId  LIN;
+	static const BusId  TAS;
+	static const BusId 	SELFDIAG;
+	static const BusId 	INVALID;	//MUST be last BusId and is not part of MAX_NUMBER_OF_BUSSES
+
+	/**
+	 * constructor
+	 * @param	name	string representation of BusId
+	 */
+	explicit BusId(const char* name);
+
+ 	/**
+ 	 * @return	the BusIds name
+ 	 */
+	const char* getName() const
+	{
+		return fpName;
+	}
+
+	/**
+	 * @return	the BusIds unique index
+	 */
+	uint8 toIndex() const
+	{
+		return fId;
+	}
+
+	uint8 toCANIndex() const;
+
+	uint8 toLINIndex() const;
+
+	/**
+	 * @param	index	index of BusId to access
+	 * @return	BusId at given index
+	 */
+	static const BusId& get(uint8 index);
+
+	/**
+	 * @return	iterator to first BusId
+	 */
+	static iterator begin();
+
+	/**
+	 * @return	iterator one past last BusId
+	 */
+	static iterator end();
+
+	/**
+	 * @return	total number of busses (excluding INVALID)
+	 */
+	static uint8 numberOfBusses()
+	{
+		return sfIdCount;
+	}
+private:
+	MAKE_UNCOPYABLE(BusId)
+
+	//friends
+	friend bool operator==(const BusId& x, const BusId& y);
+	friend bool operator!=(const BusId& x, const BusId& y);
+	friend class BusIdIterator;
+	//fields
+	uint8		fId;
+	const char* fpName;
+	//static fields
+	static uint8 	sfIdCount;
+	static BusId*	sfBusId[MAX_NUMBER_OF_BUSSES];
+};
+
+/**
+ * Compares two given BusIds
+ * @param	x	first BusId to compare
+ * @param	y	second BusId to compare
+ * @return
+ * 			- true	BusIds are equal
+ * 			- false	BusIds are not equal
+ */
+inline bool operator==(const BusId& x, const BusId& y)
+{
+	return (x.fId == y.fId);
+}
+
+/**
+ * Compares two given BusIds
+ * @param	x	first BusId to compare
+ * @param	y	second BusId to compare
+ * @return
+ * 			- true	BusIds are not equal
+ * 			- false	BusIds are equal
+ */
+inline bool operator!=(const BusId& x, const BusId& y)
+{
+	return (x.fId != y.fId);
+}
+
+/**
+ * Iterator for BusIds.
+ * @author	matthias.kessler
+ */
+class BusIdIterator
+{
+public:
+	/** pointer to a BusId */
+	typedef BusId*	pointer;
+	/** reference to a BusId */
+	typedef BusId&	reference;
+
+	/**
+	 * constructor
+	 * @param	pBusId	pointer to BusId this iterator points initially to
+	 */
+	explicit BusIdIterator(BusId* pBusId) :
+		fpBusId(pBusId)
+	{}
+
+	/**
+	 * copy constructor
+	 * @param	itr		iterator to copy from
+	 */
+	BusIdIterator(const BusIdIterator& itr) :
+		fpBusId(itr.fpBusId)
+	{}
+
+	/**
+	 * assignment operator
+	 * @param	itr		iterator to copy from
+	 */
+	BusIdIterator& operator=(const BusIdIterator& itr)
+	{
+		if (&itr != this)
+		{
+			fpBusId = itr.fpBusId;
+		}
+		return *this;
+	}
+
+	/**
+	 * @return	pointer to BusId iterator currently points to
+	 */
+	pointer operator->() const
+	{
+		return fpBusId;
+	}
+
+	/**
+	 * @return	reference to BusId iterator currently points to
+	 */
+	reference operator*() const
+	{
+		return *fpBusId;
+	}
+
+	/**
+	 * prefix increment operator
+	 * @return	next iterator
+	 */
+	BusIdIterator& operator++()
+	{
+		if (fpBusId->toIndex() < BusId::sfIdCount-2)//-2 because of INVALID is last BusId
+		{
+			fpBusId = BusId::sfBusId[fpBusId->toIndex() + 1];
+		}
+		else
+		{
+			fpBusId = 0L;
+		}
+		return *this;
+	}
+
+private:
+	//friends
+	friend bool operator==(const BusIdIterator& x, const BusIdIterator& y);
+	friend bool operator!=(const BusIdIterator& x, const BusIdIterator& y);
+	//fields
+	BusId*	fpBusId;
+};
+
+/**
+ * compares two BusIdIterators
+ * @param	x	first BusIdIterators to compare
+ * @param	y	second BusIdIterators to compare
+ * @return
+ * 			- true	BusIdIterators are equal
+ * 			- false	BusIdIterators are not equal
+ */
+inline bool operator==(const BusIdIterator& x, const BusIdIterator& y)
+{
+	return (x.fpBusId == y.fpBusId);
+}
+
+/**
+ * compares two BusIdIterators
+ * @param	x	first BusIdIterators to compare
+ * @param	y	second BusIdIterators to compare
+ * @return
+ * 			- true	BusIdIterators are not equal
+ * 			- false	BusIdIterators are equal
+ */
+inline bool operator!=(const BusIdIterator& x, const BusIdIterator& y)
+{
+	return (x.fpBusId != y.fpBusId);
+}
+
+#endif /*BUSID_H_*/

2015/ppc/gps/include/busId/BusIdMask.h

@@ -0,0 +1,18 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+/**
+ * @file	BusIdMask.h
+ */
+#ifndef BUSIDMASK_H_
+#define BUSIDMASK_H_
+
+#include "util/Mask.h"
+#include "busId/BusId.h"
+
+typedef Mask<BusId, uint32>	BusIdMask;
+
+#endif /*BUSIDMASK_H_*/

2015/ppc/gps/include/can/ICANTransceiver.h

@@ -0,0 +1,44 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+#ifndef I_CAN_TRANSCEIVER_H_
+#define I_CAN_TRANSCEIVER_H_
+
+#include "can/canframes/CANFrame.h"
+
+namespace can
+{
+class ICANTransceiver
+{
+public:
+	enum ErrorCode
+	{
+		CAN_ERR_OK,
+		CAN_ERR_TX_FAIL
+	};
+
+	virtual ErrorCode init() = 0;
+
+	virtual void shutdown() = 0;
+
+	virtual ErrorCode open() = 0;
+
+	virtual ErrorCode close() = 0;
+
+	virtual ErrorCode mute() = 0;
+
+	virtual ErrorCode unmute() = 0;
+
+	virtual ErrorCode write(const can::CANFrame& frame) = 0;
+
+	virtual uint32 getBaudrate() const = 0;
+
+	virtual uint16 getHwQueueTimeout() const = 0;
+
+};
+} // namespace can
+#endif /* end of include guard */
+

2015/ppc/gps/include/can/canframes/CANFrame.h

@@ -0,0 +1,181 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+/**
+ * Contains Cpp2CAN CANFrame.
+ * @file 		CANFrame.h
+ * @ingroup		cpp2can
+ */
+#ifndef CANFRAME_H
+#define CANFRAME_H
+
+#include "commonTypes.h"
+#include <cassert>
+
+namespace can
+{
+
+/**
+ * Class representing a CANFrame.
+ * @author		matthias.kessler
+ *
+ * A object of type CANFrame does not provide any payload-buffer by default.
+ * It has to be provided with buffers by using a certain constructor or the
+ * setPayload() method.
+ *
+ * @note
+ * CANFrame may be used as base class for special frame classes providing
+ * the programmer with explicit methods to access the signals that are
+ * encoded in the CANFrames payload.
+ */
+class CANFrame
+{
+public:
+	/** bitmask to extract sender */
+	static const uint8 	SENDER_MASK 		= 0xFF;
+	/** overhead of a CANFrame (in bit) */
+	static const uint8 	CAN_OVERHEAD_BITS	= 47;
+	/** maximum payload length of a CANFrame */
+	static const uint8	MAX_FRAME_LENGTH	= 8;
+	/** maximum value of a CANFrame id */
+	static const uint16 MAX_FRAME_ID		= 0x7FF;
+
+	/**
+	 * @post	getId() == 0x00
+	 * @post	getPayload() == NULL
+	 * @post	getPayloadLength() == 0
+	 * @post	getTimestamp() == 0
+	 */
+	CANFrame();
+
+	/**
+	 * Copy constructor
+	 * @param	frame	CANFrame to copy content from
+	 */
+	CANFrame(const CANFrame& frame);
+
+	/**
+	 * Constructor initializing id, payload and length
+	 *
+	 * @pre		id <= MAX_FRAME_ID
+	 * @pre		length <= MAX_FRAME_LENGTH
+	 * @throws	assertion
+	 *
+	 * The payload will not be copied, it is passed as a
+	 * reference and CANFrame will work on this payload!
+	 */
+	CANFrame(uint16 id, uint8 payload[], uint8 length);
+
+	uint16 	getId() const
+	{
+		return fId;
+	}
+
+	void setId(uint16 id)
+	{
+		this->fId = id;
+	}
+
+	/**
+	 * @return	pointer to modifiable payload of this CANFrame
+	 */
+	uint8* getPayload()
+	{
+		return fpPayload;
+	}
+
+	/**
+	 * @return	pointer to read only payload of this CANFrame
+	 */
+	const uint8* getPayload() const
+	{
+		return fpPayload;
+	}
+
+	/**
+	 * Sets the CANFrames payload and length
+	 *
+	 * @note
+	 * This method just sets a pointer to the payload and does not copy it!
+	 *
+	 * @post	getPayload() == payload
+	 * @post	getPayloadLength() == length
+	 * @post	getMaxPayloadLength() == length
+	 */
+	void setPayload(uint8 payload[], uint8 length)
+	{
+		fpPayload = payload;
+		fPayloadLength = length;
+		fMaxPayloadLength = length;
+	}
+
+	/**
+	 * @pre		getPayload() != NULL
+	 * @pre		length <= getMaxPayloadLength()
+	 * @throws	assertion
+	 */
+	void setPayloadLength(uint8 length);
+
+	uint8 getPayloadLength() const
+	{
+		return fPayloadLength;
+	}
+
+	uint8 getMaxPayloadLength() const
+	{
+		return fMaxPayloadLength;
+	}
+
+	/**
+	 * Assigns content of a CANFrame to another.
+	 * @param	canFrame	frame to copy from
+	 * @return	reference to frame with new content
+	 * @pre		getMaxPayloadLength() >= canFrame.getPayloadLength()
+	 * @throws	assertion
+	 */
+	CANFrame& operator=(const CANFrame& canFrame);
+
+	/**
+	 * @return	modifiable reference to timestamp
+	 */
+	uint64& getTimestamp()
+	{
+		return fTimestamp; // PRQA S 4024
+	}
+
+	/**
+	 * @return	read only access to timestamp
+	 */
+	const uint64& getTimestamp() const
+	{
+		return fTimestamp;
+	}
+
+	bool isExtended() const { return false; } /* TODO: cleanup */
+
+protected:
+	friend bool operator==(const CANFrame& frame1, const CANFrame& frame2);
+
+	uint8* 	fpPayload;
+	uint16 	fId;
+	uint8 	fPayloadLength;
+	uint8 	fMaxPayloadLength;
+	uint64	fTimestamp;
+};
+
+/**
+ * Compares two CANFrames without considering the timestamp
+ * @param	frame1	first frame to compare
+ * @param	frame2	second frame to compare
+ * @return
+ * 			- true if frames are equal
+ * 			- false if frames are not equal
+ */
+bool operator==(const CANFrame& frame1, const CANFrame& frame2);
+
+} /* namespace can */
+
+#endif /* CANFRAME_H */

2015/ppc/gps/include/can/filter/IFilter.h

@@ -0,0 +1,79 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+/**
+ * Contains IFilter interface.
+ * @file 		IFilter.h
+ * @ingroup		filter
+ */
+#ifndef IFILTER_H_
+#define IFILTER_H_
+
+#include "commonTypes.h"
+#include "util/Uncopyable.h"
+
+namespace can
+{
+//forward declaration
+class IMerger;
+
+/**
+ * common interface for filter classes
+ * @author	matthias.kessler
+ */
+class IFilter
+{
+public:
+	IFilter() {};
+
+	/**
+	 * adds a single id to the filter
+	 * @param	id	id to add
+	 * @post	filter.match(id)
+	 */
+	virtual void add(uint16 id) = 0;
+
+	/**
+	 * adds a range of ids to the filter
+	 * @param	from	begin of range
+	 * @param	to		end of range
+	 * @post	filter.match(from...to);
+	 */
+	virtual void add(uint16 from, uint16 to) = 0;
+
+	/**
+	 * checks if a given id matches the filter
+	 * @return
+	 * 			- true: id matches filter
+	 * 			- false: id does not match filter
+	 */
+	virtual bool match(uint16 id) const = 0;
+
+	/**
+	 * clears the filter so that nothing matches
+	 */
+	virtual void clear() = 0;
+
+	/**
+	 * opens the filters full range
+	 */
+	virtual void open() = 0;
+
+	/**
+	 * merges filter with a given merger
+	 * @param	merger	IMerger to merge filter to
+	 *
+	 * This is part of the visitor pattern that is used to
+	 * merge different kinds of filters.
+	 */
+	virtual void acceptMerger(IMerger& merger) = 0;
+private:
+	MAKE_UNCOPYABLE(IFilter)
+};
+
+} //namespace can
+
+#endif /*IFILTER_H_*/

2015/ppc/gps/include/can/filter/IMerger.h

@@ -0,0 +1,62 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+/**
+ * Contains IMerger interface.
+ * @file 		IMerger.h
+ * @ingroup		filter
+ */
+#ifndef _IMERGER_H_
+#define _IMERGER_H_
+
+#include "util/Uncopyable.h"
+
+namespace can
+{
+
+//forward declarations
+class BitFieldFilter;
+class AbstractStaticBitFieldFilter;
+class IntervalFilter;
+
+/**
+ * interface for class that are able to merge with other filter classes
+ * @class		IMerger
+ * @author		gerd.schaefer
+ *
+ * @see			BitFieldFilter
+ * @see			AbstractStaticBitFieldFilter
+ * @see			IntervalFilter
+ */
+class IMerger
+{
+public:
+	IMerger() {}
+
+	/**
+	 * merges with a BitFieldFilter
+	 * @param	filter	BitFieldFilter to merge with
+	 */
+	virtual void mergeWithBitField(BitFieldFilter& filter) = 0;
+
+	/**
+	 * merges with a AbstractStaticBitFieldFilter
+	 * @param	filter	AbstractStaticBitFieldFilter to merge with
+	 */
+	virtual void mergeWithStaticBitField(AbstractStaticBitFieldFilter& filter) = 0;
+
+	/**
+	 * merges with a IntervalFilter
+	 * @param	filter	IntervalFilter to merge with
+	 */
+	virtual void mergeWithInterval(IntervalFilter& filter) = 0;
+private:
+	MAKE_UNCOPYABLE(IMerger)
+};
+
+} //namespace can
+
+#endif //_IMERGER_H_

2015/ppc/gps/include/can/filter/IntervalFilter.h

@@ -0,0 +1,148 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+/**
+ * Contains IntervalFilter class.
+ * @file		IntervalFilter.h
+ * @ingroup		filter
+ */
+#ifndef _INTERVALFILTER_H_
+#define _INTERVALFILTER_H_
+
+#include "commonTypes.h"
+#include "can/canframes/CANFrame.h"
+#include "can/filter/IFilter.h"
+#include "can/filter/IMerger.h"
+#include "util/Uncopyable.h"
+
+namespace can
+{
+
+/**
+ * Cpp2CAN IntervalFilter
+ * @author		gerd.schaefer, matthias.kessler
+ *
+ * @see	IFilter
+ */
+class IntervalFilter :
+	public IFilter
+{
+public:
+	/** maximum id the filter may take */
+	static const uint16	MAX_ID	= CANFrame::MAX_FRAME_ID;
+
+	/**
+	 * constructor
+	 * @post	getLowerBound() == MAX_ID
+	 * @post	getUpperBound() == 0x0
+	 *
+	 * Nothing wil be accepted by default
+	 */
+	IntervalFilter();
+
+	/**
+	 * constructor initializing an interval
+	 * @param	from	first id that will be accepted
+	 * @param	to		last id that will be accepted
+	 * @pre		from <= MAX_ID
+	 * @pre		to <= MAX_ID
+	 * @post	getLowerBound() == from
+	 * @post	getUpperBound() == to
+	 *
+	 * @note
+	 * If from or to exceed MAX_ID, they will be set to MAX_ID.
+	 */
+	explicit IntervalFilter(uint16 from, uint16 to);
+
+	/**
+	 * @see		IFilter::add()
+	 * @param	id	id to add to filter
+	 * @pre		id <= MAX_ID, otherwise no effect
+	 * @post	getLowerBound() == min(id, getLowerBound())
+	 * @post	getUpperBound() == max(id, getUpperBound())
+	 *
+	 * @note
+	 * This call is equal to add(id, id).
+	 */
+	virtual void add(uint16 id)
+	{
+		if (id <= MAX_ID)
+		{
+			add(id, id);
+		}
+	}
+
+	/**
+	 * @see		IFilter::add()
+	 * @param	from	lower bound of interval to add
+	 * @param	to		upper bound of interval to add
+	 * @pre		from <= MAX_ID
+	 * @pre		to <= MAX_ID
+	 * @post	getLowerBound() == min(from, getLowerBound())
+	 * @post	getUpperBound() == max(to, getUpperBound())
+	 *
+	 * If from or to exceed MAX_ID, they will be set to MAX_ID.
+	 *
+	 * This call will not replace the current filter configuration, but
+	 * adjust lower and upper bound of the filter according to the parameters.
+	 */
+	virtual void add(uint16 from, uint16 to);
+
+	/**
+	 * checks if an id matches the filter
+	 * @param	id		id to check
+	 * @return
+	 * 			- true: filter matches id
+	 * 			- false: id is not in filters range
+	 */
+	virtual bool match(uint16 id) const
+	{
+		return (id >= fFrom) && (id <= fTo);
+	}
+
+	/**
+	 * @see		IFilter::acceptMerger()
+	 */
+	virtual void acceptMerger(IMerger& merger)
+	{
+		merger.mergeWithInterval(*this);
+	}
+
+	/**
+	 * @see		IFilter::clear();
+	 */
+	virtual void clear();
+
+	/**
+	 * @see		IFilter::open();
+	 */
+	virtual void open();
+
+	/**
+	 * @return	lower bound of filter
+	 */
+	uint16 getLowerBound() const
+	{
+		return fFrom;
+	}
+
+	/**
+	 * @return	upper bound of filter
+	 */
+	uint16 getUpperBound() const
+	{
+		return fTo;
+	}
+private:
+	MAKE_UNCOPYABLE(IntervalFilter)
+	//fields
+	uint16 fFrom;
+	uint16 fTo;
+};
+
+} /*namespace can*/
+
+#endif //_INTERVALFILTER_H_

2015/ppc/gps/include/can/framemgmt/ICANFrameListener.h

@@ -0,0 +1,50 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+/**
+ * Contains interface ICANFrameListener.
+ * @file 		ICANFrameListener.h
+ * @ingroup		framemgmt
+ */
+#ifndef ICANFRAMELISTENER_H
+#define ICANFRAMELISTENER_H
+
+#include "util/SLinkedListSet.h"
+#include "util/Uncopyable.h"
+
+namespace can
+{
+class CANFrame;
+class IFilter;
+
+/**
+ * CANFrameListener interface
+ * @author		matthias.kessler
+ *
+ * An ICANFrameListener subclass is a class interested in the reception
+ * of CANFrames. Therefore it needs to register at an AbstractCANTransceiver.
+ */
+class ICANFrameListener :
+	public SLinkedListSetNode<ICANFrameListener>
+{
+	MAKE_UNCOPYABLE(ICANFrameListener)
+public:
+	ICANFrameListener() {}
+
+	/**
+	 * This method notifies the listener of a CANFrame reception.
+	 */
+	virtual void frameReceived(const CANFrame& canFrame) = 0;
+
+	/**
+	 * Returns the ICANFrameListeners filter.
+	 */
+	virtual IFilter& getFilter() = 0;
+};
+
+} //namespace can
+
+#endif // ICANFRAMELISTENER_H

2015/ppc/gps/include/gps/GpsConverter.h

@@ -0,0 +1,48 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+#ifndef GPSCONVERTER_H_
+#define GPSCONVERTER_H_
+
+#include "commonTypes.h"
+#include "can/framemgmt/ICANFrameListener.h"
+#include "can/filter/IntervalFilter.h"
+
+namespace can
+{
+class CANFrame;
+class ICANTransceiver;
+}
+namespace gps
+{
+class IGpsACPusher;
+
+class GpsConverter :
+	public can::ICANFrameListener
+{
+public:
+	enum { GPS_FRAME_ID = 0x34a }; //NavGps1
+	GpsConverter(can::ICANTransceiver& transceiver, IGpsACPusher& acPusher);
+
+	/* ICANFrameListener */
+	virtual void frameReceived(const can::CANFrame& canFrame);
+	virtual can::IFilter& getFilter()
+	{
+		return fCanFilter;
+	}
+
+private:
+	can::ICANTransceiver& fCanTransceiver;
+	can::IntervalFilter	fCanFilter;
+
+	IGpsACPusher& fAcPusher;
+	sint32 fLastLatInMs;
+	sint32 fLastLongInMs;
+};
+
+} // namespace gps
+#endif /* end of include guard */
+

2015/ppc/gps/rakefile.rb

@@ -0,0 +1,7 @@
+
+desc "run unittests"
+task :runTests do
+  sh "bake -b UnitTest -a black --include_filter run"
+end
+task :default => :run
+

2015/ppc/gps/src/ac/GpsACPusher.cpp

@@ -0,0 +1,33 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+#include "gps/AcPusher.h"
+#include "android/caim/base/ICaimTransceiver.h"
+#include "util/endian.h"
+
+namespace gps
+{
+
+void GpsAcPusher::pushGPSCoordinates(sint32 latMs, sint32 longMs)
+{
+	uint8 newPosition[sizeof(fPosition)];
+
+	writeMem32(newPosition + LONGITUDE_OFFSET, longMs);
+	writeMem32(newPosition + LATITUDE_OFFSET, latMs);
+
+	writeMem16(newPosition + HEIGHT_OFFSET, 0);
+	writeMem16(newPosition + SPEED_OFFSET, 0);
+	newPosition[HEADING_OFFSET] = 0;
+	writeMem16(newPosition + QUALITY_OFFSET, 0);
+
+	if (memcmp(newPosition, fPosition, sizeof(fPosition)))
+	{
+		memcpy(fPosition, newPosition, sizeof(fPosition));
+		fCaimTransceiver.push(POSITION_COMMAND, fPosition, sizeof(fPosition));
+	}
+}
+} // namespace gps
+

2015/ppc/gps/src/can/canframes/CANFrame.cpp

@@ -0,0 +1,99 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+#include "can/canframes/CANFrame.h"
+
+namespace can
+{
+
+//define const variables for GCC
+#ifdef __GNUC__
+const uint8 CANFrame::SENDER_MASK;
+const uint8 CANFrame::CAN_OVERHEAD_BITS;
+const uint8	CANFrame::MAX_FRAME_LENGTH;
+const uint16 CANFrame::MAX_FRAME_ID;
+#endif
+
+CANFrame::CANFrame() :
+	fpPayload(0L),
+	fId(0),
+	fPayloadLength(0),
+	fMaxPayloadLength(0),
+	fTimestamp(0)
+{}
+
+CANFrame::CANFrame(const CANFrame& frame) :
+	fpPayload(frame.fpPayload),
+	fId(frame.fId),
+	fPayloadLength(frame.fPayloadLength),
+	fMaxPayloadLength(frame.fMaxPayloadLength),
+	fTimestamp(frame.fTimestamp)
+{
+}
+
+CANFrame::CANFrame(uint16 id, uint8 payload[], uint8 length) :
+	fpPayload(payload),
+	fId(id),
+	fPayloadLength(length),
+	fMaxPayloadLength(length)
+{
+	assert(id <= MAX_FRAME_ID);
+	assert(length <= MAX_FRAME_LENGTH);
+}
+
+CANFrame& CANFrame::operator=(const CANFrame& canFrame)
+{
+	if (&canFrame != this)
+	{
+		if (fMaxPayloadLength < canFrame.fPayloadLength)
+		{
+			assert(fMaxPayloadLength >= canFrame.fPayloadLength);
+		}
+		fId = canFrame.fId;
+		for (uint8 i = 0; i < canFrame.fPayloadLength; ++i)
+		{
+			fpPayload[i] = canFrame.fpPayload[i];
+		}
+		fPayloadLength = canFrame.fPayloadLength;
+		fTimestamp = canFrame.fTimestamp;
+	}
+	return *this;
+}
+
+void CANFrame::setPayloadLength(uint8 length)
+{
+	if (!fpPayload)
+	{
+		assert(fpPayload != 0L);
+	}
+	if (length > fMaxPayloadLength)
+	{
+		assert(length <= fMaxPayloadLength);
+	}
+	fPayloadLength = length;
+}
+
+bool operator==(const CANFrame& frame1, const CANFrame& frame2)
+{
+	if (frame1.fId != frame2.fId)
+	{
+		return false;
+	}
+	if (frame1.fPayloadLength != frame2.fPayloadLength)
+	{
+		return false;
+	}
+	for (uint8 i = 0; i < frame1.fPayloadLength; i++)
+	{
+		if (frame1.fpPayload[i] != frame2.fpPayload[i])
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+} //namespace can

2015/ppc/gps/src/can/filter/IntervalFilter.cpp

@@ -0,0 +1,69 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+#include "can/filter/IntervalFilter.h"
+#include "util/SAlgorithm.h"
+
+namespace can
+{
+
+#ifdef __GNUC__
+const uint16 IntervalFilter::MAX_ID;
+#endif
+
+IntervalFilter::IntervalFilter()
+{
+	clear();
+}
+
+IntervalFilter::IntervalFilter(uint16 from, uint16 to) :
+	fFrom(from),
+	fTo(to)
+{
+	if (from > MAX_ID)
+	{
+		fFrom = MAX_ID;
+	}
+	if (to > MAX_ID)
+	{
+		fTo = MAX_ID;
+	}
+}
+
+void IntervalFilter::add(uint16 from, uint16 to)
+{
+	if (from > MAX_ID)
+	{
+		from = MAX_ID;
+	}
+	if (to > MAX_ID)
+	{
+		to = MAX_ID;
+	}
+	//assert order
+	if (from > to)
+	{
+		sswap(from, to);
+	}
+	//adjust lower bound
+	fFrom = smin(fFrom, from);
+	//adjust upper bound
+	fTo = smax(fTo, to);
+}
+
+void IntervalFilter::clear()
+{
+	fFrom 	= MAX_ID;
+	fTo		= 0;
+}
+
+void IntervalFilter::open()
+{
+	fFrom 	= 0x0;
+	fTo		= MAX_ID;
+}
+
+} /*namespace can*/

2015/ppc/gps/src/gps/GpsConverter.cpp

@@ -0,0 +1,36 @@
+/**
+ * \copyright
+ * (c) 2012 - 2015 E.S.R. Labs GmbH (http://www.esrlabs.com)
+ * All rights reserved.
+ */
+
+#include "gps/GpsConverter.h"
+#include "ac/IGpsACPusher.h"
+#include "can/canframes/CANFrame.h"
+#include "can/ICANTransceiver.h"
+#include <stdio.h>
+
+using namespace can;
+
+namespace gps
+{
+
+GpsConverter::GpsConverter(
+		ICANTransceiver& transceiver,
+		IGpsACPusher& acPusher)
+	: fCanTransceiver(transceiver)
+	, fCanFilter(GPS_FRAME_ID, GPS_FRAME_ID)
+	, fAcPusher(acPusher)
+{
+}
+
+void GpsConverter::frameReceived(const CANFrame& canFrame)
+{
+	const uint8* payload = canFrame.getPayload();
+    // TOOD implement conversion to arc-msec and call IGpsACPusher
+}
+
+
+} // namespace gps
+
+

2015/ppc/gps/test/CanTransceiverMock.h

@@ -0,0 +1,53 @@
+#ifndef CANTRANSCEIVER_MOCK_H_
+#define CANTRANSCEIVER_MOCK_H_
+
+#include "can/ICANTransceiver.h"
+#include "busId/BusId.h"
+
+namespace can
+{
+
+class CanTransceiverMock
+	: public ICANTransceiver
+{
+public:
+	CanTransceiverMock()
+	{}
+	virtual ErrorCode init()
+	{
+		return CAN_ERR_OK;
+	}
+	virtual void shutdown() {}
+	virtual ErrorCode open()
+	{
+		return CAN_ERR_OK;
+	}
+	virtual ErrorCode close()
+	{
+		return CAN_ERR_OK;
+	}
+	virtual ErrorCode mute()
+	{
+		return CAN_ERR_OK;
+	}
+	virtual ErrorCode unmute()
+	{
+		return CAN_ERR_OK;
+	}
+	virtual ErrorCode write(const can::CANFrame& frame)
+	{
+		return CAN_ERR_OK;
+	}
+	virtual uint32 getBaudrate() const
+	{
+		return 500000;
+	}
+	virtual uint16 getHwQueueTimeout() const
+	{
+		return 50;
+	}
+};
+} // namespace can
+#endif /* end of include guard */
+
+

2015/ppc/gps/test/GpsConverterTest.cpp

@@ -0,0 +1,110 @@
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+#include "commonTypes.h"
+#include "can/canframes/CANFrame.h"
+#include "gps/GpsConverter.h"
+#include "ac/IGpsACPusher.h"
+#include "CanTransceiverMock.h"
+#include "busId/BusId.h"
+
+using namespace gps;
+using namespace common;
+using namespace can;
+
+namespace test
+{
+
+class GpsAcPusherMock : public gps::IGpsACPusher
+{
+public:
+	GpsAcPusherMock()
+		: gpsWasSet(false)
+	{}
+	virtual void pushGPSCoordinates(sint32 latMs, sint32 longMs)
+	{
+		printf("pushGPSCoordinates received: %d and %d\n", latMs, longMs);
+		gpsWasSet = true;
+		latitudeMs = latMs;
+		longitudeMs = longMs;
+	}
+	void clear()
+	{
+		gpsWasSet = false;
+		latitudeMs = 0;
+		longitudeMs = 0;
+	}
+	sint32 latitudeMs;
+	sint32 longitudeMs;
+	bool gpsWasSet;
+};
+class GpsConverterTest
+{
+public:
+	GpsConverterTest()
+		: canTransceiverMock()
+		, converter(canTransceiverMock, acPusherMock)
+	{}
+
+	virtual ~GpsConverterTest() {}
+
+	can::CanTransceiverMock canTransceiverMock;
+	GpsAcPusherMock acPusherMock;
+	GpsConverter converter;
+};
+
+static bool withinTolerance(sint32 x1, sint32 x2, sint32 tolerance)
+{
+	return abs(x1-x2) < tolerance;
+}
+
+TEST_CASE_METHOD(GpsConverterTest, "london east calling", "[gps]")
+{
+	uint8 payload[8] = { 0xDF, 0x48, 0xEA, 0xFF, 0x08, 0xC5, 0xA5, 0x24 };
+	CANFrame gpsInfo(0x34a, payload, 8);
+	converter.frameReceived(gpsInfo);
+	CHECK(acPusherMock.gpsWasSet);
+	CHECK(withinTolerance(acPusherMock.latitudeMs, 185528159, 100));
+	CHECK(withinTolerance(acPusherMock.longitudeMs, -429429, 100));
+}
+
+TEST_CASE_METHOD(GpsConverterTest, "london west calling", "[gps]")
+{
+	uint8 payload[8] = { 0x1F, 0xB7, 0x15, 0x00, 0x08, 0xC5, 0xA5, 0x24 };
+	CANFrame gpsInfo(0x34a, payload, 8);
+	converter.frameReceived(gpsInfo);
+	SECTION("receive once")
+	{
+		CHECK(acPusherMock.gpsWasSet);
+		CHECK(withinTolerance(acPusherMock.latitudeMs, 185528159, 100));
+		CHECK(withinTolerance(acPusherMock.longitudeMs, 429428, 100));
+	}
+	SECTION("receive twice same value, only propagate once")
+	{
+		CHECK(acPusherMock.gpsWasSet);
+		CHECK(withinTolerance(acPusherMock.latitudeMs, 185528159, 100));
+		CHECK(withinTolerance(acPusherMock.longitudeMs, 429428, 100));
+		acPusherMock.clear();
+		converter.frameReceived(gpsInfo);
+		CHECK(!acPusherMock.gpsWasSet);
+	}
+}
+TEST_CASE_METHOD(GpsConverterTest, "invalid data", "[gps]")
+{
+	uint8 payload[8] = { 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80 };
+	CANFrame gpsInfo(0x34a, payload, 8);
+	converter.frameReceived(gpsInfo);
+	CHECK(!acPusherMock.gpsWasSet);
+}
+TEST_CASE_METHOD(GpsConverterTest, "no signal", "[gps]")
+{
+	uint8 payload[8] = { 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F };
+	CANFrame gpsInfo(0x34a, payload, 8);
+	converter.frameReceived(gpsInfo);
+	CHECK(!acPusherMock.gpsWasSet);
+}
+// 48.1172966,11.5913253
+// 48.1173275,11.591452
+
+} // namespace test
+
+

2015/ppc/rakefile.rb

@@ -0,0 +1,15 @@
+
+desc "build"
+task :build do
+  sh "bake -m gps -b UnitTest -a black"
+end
+
+desc "run"
+task :run => :build do
+  sh "./gps/UnitTest/gpsTests.exe"
+end
+
+desc "clean"
+task :clean do
+  sh "bake -m gps -b UnitTest -a black -c"
+end