Change directory architecture to use 2 separated projects.

Each projects, binder and generator, has to be compiled separatly.
CAN-binder will host high and low level binding
CAN-config-generator only the generator used for low level binding.
build.sh script just launch both build in their respective dir.

Change-Id: Ic77932660fcca507b23a631d4e4e790f608880ae
Signed-off-by: Romain Forlot <romain.forlot@iot.bzh>

10 files changed, 907 insertions, 0 deletions

diff --git a/CAN-binder/low-can-binding/utils/config-parser.cpp b/CAN-binder/low-can-binding/utils/config-parser.cpp
new file mode 100644
index 0000000..e73b0f9
--- /dev/null
+++ b/CAN-binder/low-can-binding/utils/config-parser.cpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2015, 2016 ,2017 "IoT.bzh"
+ * Author "Romain Forlot" <romain.forlot@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace utils
+{
+	config_parser_t::config_parser_t(int conf_file)
+		: conf_file_{conf_file}, devices_name{}
+	{}
+
+	/// @brief read the conf_file_ and will parse json objects
+	/// in it searching for canbus objects devices name.
+	///
+	/// @return Vector of can bus device name string.
+	void can_bus_t::read_conf()
+	{
+		FILE *fd = fdopen(conf_file_, "r");
+		if (fd)
+		{
+			std::fseek(fd, 0, SEEK_END);
+			config_content_.resize(std::ftell(fd));
+			std::rewind(fd);
+			std::fread(&config_content_[0], 1, config_content_.size(), fd);
+			std::fclose(fd);
+
+			DEBUG(binder_interface, "Configuration file content : %s", config_content_.c_str());
+		}
+		ERROR(binder_interface, "Problem at reading the conf file");
+	}
+
+	void parse_devices_name()
+	{
+		json_object *jo, *canbus;
+		const char* taxi;
+
+		jo = json_tokener_parse(config_content_.c_str());
+
+			if (jo == NULL || !json_object_object_get_ex(jo, "canbus", &canbus))
+			{
+				ERROR(binder_interface, "Can't find canbus node in the configuration file. Please review it.");
+				devices_name_.clear();
+			}
+			else if (json_object_get_type(canbus) != json_type_array)
+			{
+				taxi = json_object_get_string(canbus);
+				DEBUG(binder_interface, "Can bus found: %s", taxi);
+				devices_name_.push_back(std::string(taxi));
+			}
+			else
+			{
+				int n, i;
+				n = json_object_array_length(canbus);
+				for (i = 0 ; i < n ; i++)
+					devices_name_.push_back(json_object_get_string(json_object_array_get_idx(canbus, i)));
+			}
+	}
+
+	/// @brief Public method to access devices_name_ vector. If vector size equal 0
+	/// then it will parses the configuration file content to fill it. It could be empty even
+	/// after parsing if content file just don't have a correct "canbus" directive so you
+	/// have to test the returned value.
+	///
+	/// @return A const vector with string of linux CAN devices.
+	const std::vector<std::string>& get_devices_name()
+	{
+		if(devices_name_.empty())
+			parse_devices_name();
+
+		return devices_name_;
+	}
+}
\ No newline at end of file
diff --git a/CAN-binder/low-can-binding/utils/config-parser.hpp b/CAN-binder/low-can-binding/utils/config-parser.hpp
new file mode 100644
index 0000000..e6bd9d2
--- /dev/null
+++ b/CAN-binder/low-can-binding/utils/config-parser.hpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2015, 2016 ,2017 "IoT.bzh"
+ * Author "Romain Forlot" <romain.forlot@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <json-c/json.h>
+
+#include <string>
+
+namespace utils
+{
+	class config_parser_t
+	{
+	private:
+		int conf_file_; /*!< conf_file_ - file that handle the binding configuration file */
+		std::string config_content_; /*!< config_content_ - String that contains the content of config file */
+		std::vector<std::string> devices_name_; /*!< devices_name - Found devices name after reading configuration file */
+
+		void parse_devices_name();
+	public:
+		config_parser_t(int conf_file);
+
+		void read_conf();
+		std::vector<std::string> get_devices_name();
+	};
+}
diff --git a/CAN-binder/low-can-binding/utils/openxc-utils.cpp b/CAN-binder/low-can-binding/utils/openxc-utils.cpp
new file mode 100644
index 0000000..52b49d2
--- /dev/null
+++ b/CAN-binder/low-can-binding/utils/openxc-utils.cpp
@@ -0,0 +1,282 @@
+/*
+ * Copyright (C) 2015, 2016 "IoT.bzh"
+ * Author "Romain Forlot" <romain.forlot@iot.bzh>
+ * Author "Loic Collignon" <loic.collignon@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "openxc-utils.hpp"
+
+#include "../configuration.hpp"
+
+///
+/// @brief Build a specific VehicleMessage containing a DiagnosticResponse.
+///
+/// @param[in] request - Original request use to retrieve decoder and callback
+/// @param[in] response - Response to the request that will be decoded if decoder set
+///  and put into the DiagnosticResponse of the VehicleMessage.
+/// @param[in] parsed_value - raw parsed value of the payload from CAN message
+///
+/// @return a vehicle message including simple message that will be convert into 
+/// a JSON object before being pushed to the subscribers
+///
+openxc_VehicleMessage build_VehicleMessage(active_diagnostic_request_t* request, const DiagnosticResponse& response, float parsed_value)
+{
+	openxc_VehicleMessage message;
+
+	message.has_type = true;
+	message.type = openxc_VehicleMessage_Type::openxc_VehicleMessage_Type_DIAGNOSTIC;
+	message.has_diagnostic_response = true;
+	message.diagnostic_response.has_bus = true;
+	message.diagnostic_response.bus = configuration_t::instance().get_diagnostic_manager().get_can_bus_dev()->get_address();
+	message.diagnostic_response.has_message_id = true;
+
+	if(request->get_id() != OBD2_FUNCTIONAL_BROADCAST_ID)
+	{
+		message.diagnostic_response.message_id = response.arbitration_id
+			- DIAGNOSTIC_RESPONSE_ARBITRATION_ID_OFFSET;
+	}
+	else
+	{
+		// must preserve responding arb ID for responses to functional broadcast
+		// requests, as they are the actual module address and not just arb ID +
+		// 8.
+		message.diagnostic_response.message_id = response.arbitration_id;
+	}
+
+	message.diagnostic_response.has_mode = true;
+	message.diagnostic_response.mode = response.mode;
+	message.diagnostic_response.has_pid = response.has_pid;
+	if(message.diagnostic_response.has_pid)
+		message.diagnostic_response.pid = response.pid;
+	message.diagnostic_response.has_success = true;
+	message.diagnostic_response.success = response.success;
+	message.diagnostic_response.has_negative_response_code = !response.success;
+	message.diagnostic_response.negative_response_code =
+			response.negative_response_code;
+
+	if(response.payload_length > 0)
+	{
+		if(request->get_decoder() != nullptr)
+		{
+			message.diagnostic_response.has_value = true;
+			message.diagnostic_response.value = parsed_value;
+		}
+		else
+		{
+			message.diagnostic_response.has_payload = true;
+			::memcpy(message.diagnostic_response.payload.bytes, response.payload,
+					response.payload_length);
+			message.diagnostic_response.payload.size = response.payload_length;
+		}
+	}
+
+	return message;
+}
+
+///
+/// @brief Build a specific VehicleMessage containing a SimpleMessage.
+///
+/// @param[in] message - simple message to include into openxc_VehicleMessage
+///
+/// @return a vehicle message including simple message that will be convert into 
+/// a JSON object before being pushed to the subscribers
+///
+openxc_VehicleMessage build_VehicleMessage(const openxc_SimpleMessage& message)
+{
+	openxc_VehicleMessage v;
+	
+	v.has_type = true,
+	v.type = openxc_VehicleMessage_Type::openxc_VehicleMessage_Type_SIMPLE;
+	v.has_simple_message = true;
+	v.simple_message =  message;
+	v.has_timestamp = true;
+	v.timestamp = system_time_ms();
+
+	return v;
+}
+
+///
+/// @brief Build an empty VehicleMessage that isn't usable by at least the struct
+///  is initialized for the most part and can be use to check a false return value.
+///
+/// @return A VehicleMessage with all boolean value to false.
+///
+openxc_VehicleMessage build_VehicleMessage()
+{
+	openxc_VehicleMessage v;
+
+	::memset(&v, 0, sizeof(openxc_VehicleMessage));
+	return v;
+}
+
+bool is_valid(const openxc_VehicleMessage& v)
+{
+	if (v.has_type == false &&
+		v.has_can_message == false &&
+		v.has_simple_message == false &&
+		v.has_diagnostic_response == false &&
+		v.has_control_command == false &&
+		v.has_command_response == false &&
+		v.has_timestamp == false)
+			return false;
+	return true;
+}
+
+///
+/// @brief Build an openxc_SimpleMessage associating a name to an openxc_DynamicField
+///
+/// @param[in] name - const string reference name to assign to the created SimpleMessage
+///  this will set has_name member to true and assign name to the name member. Maximum size for name is 
+///  set to 100 char.
+/// @param[in] value - const reference with DynamicField to assign to SimpleMessage
+///  value.
+///
+/// @return an openxc_SimpleMessage struct initialized with name and value provided.
+///
+openxc_SimpleMessage build_SimpleMessage(const std::string& name, const openxc_DynamicField& value)
+{
+	openxc_SimpleMessage s;
+
+	s.has_name = true;
+	::strncpy(s.name, name.c_str(), 100);
+	s.has_value = true;
+	s.value = value;
+
+	return s;
+}
+
+///
+/// @brief Build an openxc_DynamicField with a string value
+///
+/// @param[in] value - const string reference value to assign to builded
+///  openxc_DynamicField.
+///
+/// @return openxc_DynamicField initialized with a string value.
+///
+openxc_DynamicField build_DynamicField(const std::string& value)
+{
+	openxc_DynamicField d;
+	d.has_type = true;
+	d.type = openxc_DynamicField_Type_STRING;
+	
+	d.has_string_value = true;
+	d.has_numeric_value = false;
+	d.has_boolean_value = false;
+	::strncpy(d.string_value, value.c_str(), 100);
+	
+	return d;
+}
+
+///
+/// @fn openxc_DynamicField build_DynamicField(double value);
+///
+/// @brief Build an openxc_DynamicField with a double value
+///
+/// @param[in] value - double value to assign to builded openxc_DynamicField.
+///
+/// @return openxc_DynamicField initialized with a double value.
+///
+openxc_DynamicField build_DynamicField(double value)
+{
+	openxc_DynamicField d;
+	d.has_type = true;
+	d.type = openxc_DynamicField_Type_NUM;
+	
+	d.has_string_value = false;
+	d.has_numeric_value = true;
+	d.has_boolean_value = false;
+	d.numeric_value = value;
+	
+	return d;
+}
+
+///
+/// @brief Build an openxc_DynamicField with a boolean value
+///
+/// @param[in] value - boolean value to assign to builded openxc_DynamicField.
+///
+/// @return openxc_DynamicField initialized with a boolean value.
+///
+openxc_DynamicField build_DynamicField(bool value)
+{
+	openxc_DynamicField d;
+	d.has_type = true;
+	d.type = openxc_DynamicField_Type_BOOL;
+	
+	d.has_string_value = false;
+	d.has_numeric_value = false;
+	d.has_boolean_value = true;
+	d.boolean_value = value;
+	
+	return d;
+}
+
+///
+/// @brief Extract the simple message value from an openxc_VehicleMessage
+///  and return it. If there isn't SimpleMessage in the VehicleMessage then
+///  returned value will be a SimpleMessage with all field set at false.
+///  DynamicField from SimpleMessage will be boolean DynamicField set to false too.
+///
+/// @param[in] v_msg - const reference to openxc_VehicleMessage
+///
+/// @return A simpleMessage from the provided VehicleMessage.
+///
+openxc_SimpleMessage get_simple_message(const openxc_VehicleMessage& v_msg)
+{
+	if (v_msg.has_simple_message)
+		return v_msg.simple_message;
+	
+	openxc_SimpleMessage s_msg = { false, "", false, build_DynamicField(false), false, build_DynamicField(false)};
+	return s_msg;
+}
+
+///
+/// @brief Make a JSON object from a DynamicField
+///
+/// @param[in] field - openxc_DynamicField struct to convert into
+///  a json object.
+/// @param[out] value - pointer to the object to set up.
+///
+void jsonify_DynamicField(const openxc_DynamicField& field, json_object* value)
+{
+	if(field.has_numeric_value)
+		json_object_object_add(value, "value", json_object_new_double(field.numeric_value));
+	else if(field.has_boolean_value)
+		json_object_object_add(value, "value", json_object_new_boolean(field.boolean_value));
+	else if(field.has_string_value)
+		json_object_object_add(value, "value", json_object_new_string(field.string_value));
+}
+
+///
+/// @brief Make a JSON object from a SimpleMessage
+///
+/// @param[in] s_msg - const reference to an openxc_SimpleMessage 
+/// struct to convert into a json object.
+/// @param[out] json - pointer with the DynamicField converted into json object
+/// 
+/// @return True if SimpleMessage has been transformed into json object
+///  and false if not. In such case, a json object is returned { "error": "error msg"}
+///
+bool jsonify_simple(const openxc_SimpleMessage& s_msg, json_object* json)
+{
+	if(s_msg.has_name)
+	{
+		json_object_object_add(json, "name", json_object_new_string(s_msg.name));
+		jsonify_DynamicField(s_msg.value, json);
+		return true;
+	}
+	json_object_object_add(json, "error", json_object_new_string("openxc_SimpleMessage doesn't have name'"));
+	return false;
+}
\ No newline at end of file
diff --git a/CAN-binder/low-can-binding/utils/openxc-utils.hpp b/CAN-binder/low-can-binding/utils/openxc-utils.hpp
new file mode 100644
index 0000000..d36b359
--- /dev/null
+++ b/CAN-binder/low-can-binding/utils/openxc-utils.hpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2015, 2016 "IoT.bzh"
+ * Author "Romain Forlot" <romain.forlot@iot.bzh>
+ * Author "Loic Collignon" <loic.collignon@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <json-c/json.h>
+#include <sys/timeb.h>
+
+#include "openxc.pb.h"
+#include "../diagnostic/active-diagnostic-request.hpp"
+
+openxc_VehicleMessage build_VehicleMessage(active_diagnostic_request_t* request, const DiagnosticResponse& response, float parsed_value);
+openxc_VehicleMessage build_VehicleMessage(const openxc_SimpleMessage& message);
+openxc_VehicleMessage build_VehicleMessage();
+bool is_valid(const openxc_VehicleMessage& v);
+
+openxc_SimpleMessage build_SimpleMessage(const std::string& name, const openxc_DynamicField& value);
+openxc_DynamicField build_DynamicField(const std::string& value);
+openxc_DynamicField build_DynamicField(double value);
+openxc_DynamicField build_DynamicField(bool value);
+
+openxc_SimpleMessage get_simple_message(const openxc_VehicleMessage& v_msg);
+
+void jsonify_DynamicField(const openxc_DynamicField& field, json_object* value);
+
+bool jsonify_simple(const openxc_SimpleMessage& s_msg, json_object* json);
\ No newline at end of file
diff --git a/CAN-binder/low-can-binding/utils/signals.cpp b/CAN-binder/low-can-binding/utils/signals.cpp
new file mode 100644
index 0000000..2e14a98
--- /dev/null
+++ b/CAN-binder/low-can-binding/utils/signals.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2015, 2016 "IoT.bzh"
+ * Author "Romain Forlot" <romain.forlot@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "signals.hpp"
+
+/// 
+/// @brief Can signal event map making access to afb_event
+/// externaly to an openxc existing structure.
+///
+/// Event map is making relation between can_signal_t generic name
+/// and the afb_event struct used by application framework to pushed
+/// to the subscriber.
+///
+std::map<std::string, struct afb_event> subscribed_signals;
+
+///
+/// @brief Mutex allowing safe manipulation on subscribed_signals map.
+/// To ensure that the map object isn't modified when we read it, you
+///  have to set this mutex before use subscribed_signals map object.
+///
+std::mutex subscribed_signals_mutex;
+
+std::mutex& get_subscribed_signals_mutex()
+{
+	return subscribed_signals_mutex;
+}
+
+std::map<std::string, struct afb_event>& get_subscribed_signals()
+{
+	return subscribed_signals;
+}
+
+///
+/// @fn std::vector<std::string> find_signals(const openxc_DynamicField &key)
+/// @brief return signals name found searching through CAN_signals and OBD2 pid
+///
+/// @param[in] key : can contain numeric or string value in order to search against 
+///   can signals or obd2 signals name.
+///
+/// @return Vector of signals name found. 
+///
+std::vector<std::string> find_signals(const openxc_DynamicField &key)
+{
+	std::vector<std::string> found_signals_name;
+
+	switch(key.type)
+	{
+		case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING:
+				lookup_signals_by_name(key.string_value, configuration_t::instance().get_can_signals(), found_signals_name);
+				lookup_signals_by_name(key.string_value, configuration_t::instance().get_diagnostic_messages(), found_signals_name);
+			break;
+		case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM:
+				lookup_signals_by_id(key.numeric_value, configuration_t::instance().get_can_signals(), found_signals_name);
+				lookup_signals_by_id(key.numeric_value, configuration_t::instance().get_diagnostic_messages(), found_signals_name);
+			break;
+		default:
+			ERROR(binder_interface, "find_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
+			break;
+	}
+	DEBUG(binder_interface, "find_signals: Found %d signal(s)", (int)found_signals_name.size());
+	return found_signals_name;
+}
diff --git a/CAN-binder/low-can-binding/utils/signals.hpp b/CAN-binder/low-can-binding/utils/signals.hpp
new file mode 100644
index 0000000..e941756
--- /dev/null
+++ b/CAN-binder/low-can-binding/utils/signals.hpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2015, 2016 "IoT.bzh"
+ * Author "Romain Forlot" <romain.forlot@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <vector>
+#include <string>
+#include <fnmatch.h>
+
+#include "openxc.pb.h"
+#include "../configuration.hpp"
+#include "../can/can-signals.hpp"
+#include "../diagnostic/diagnostic-message.hpp"
+
+#include "../low-can-binding.hpp"
+
+extern std::mutex subscribed_signals_mutex;
+std::mutex& get_subscribed_signals_mutex();
+
+/**
+ * @brief return the subscribed_signals map.
+ * 
+ * return Map of subscribed signals.
+ */
+extern std::map<std::string, struct afb_event> subscribed_signals;
+std::map<std::string, struct afb_event>& get_subscribed_signals();
+
+template <typename T>
+void lookup_signals_by_name(const std::string& key, std::vector<T>& signals, std::vector<T*>& found_signals)
+{
+	for(T& s : signals)
+	{
+		if(::fnmatch(key.c_str(), s.get_generic_name().c_str(), FNM_CASEFOLD) == 0)
+			found_signals.push_back(&s);
+		if(::fnmatch(key.c_str(), s.get_name().c_str(), FNM_CASEFOLD) == 0)
+			found_signals.push_back(&s);
+	}
+}
+
+template <typename T>
+void lookup_signals_by_name(const std::string& key, std::vector<T>& signals, std::vector<std::string>& found_signals_name)
+{
+	for(T& s : signals)
+	{
+		if(::fnmatch(key.c_str(), s.get_generic_name().c_str(), FNM_CASEFOLD) == 0)
+			found_signals_name.push_back(s.get_name());
+		if(::fnmatch(key.c_str(), s.get_name().c_str(), FNM_CASEFOLD) == 0)
+			found_signals_name.push_back(s.get_name());
+	}
+}
+
+template <typename T>
+void lookup_signals_by_id(const double key, std::vector<T>& signals, std::vector<T*>& found_signals)
+{
+	for(T& s : signals)
+	{
+		if(configuration_t::instance().get_signal_id(s) == key)
+		{
+			found_signals.push_back(&s);
+		}
+	}
+}
+
+template <typename T>
+void lookup_signals_by_id(const double key, std::vector<T>& signals, std::vector<std::string>& found_signals_name)
+{
+	for(T& s : signals)
+	{
+		if(configuration_t::instance().get_signal_id(s) == key)
+		{
+			found_signals_name.push_back(s.get_name());
+		}
+	}
+}
+
+std::vector<std::string> find_signals(const openxc_DynamicField &key);
diff --git a/CAN-binder/low-can-binding/utils/socket.cpp b/CAN-binder/low-can-binding/utils/socket.cpp
new file mode 100644
index 0000000..e75e27f
--- /dev/null
+++ b/CAN-binder/low-can-binding/utils/socket.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2015, 2016 ,2017 "IoT.bzh"
+ * Author "Romain Forlot" <romain.forlot@iot.bzh>
+ * Author "Loïc Collignon" <loic.collignon@iot.bzh>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <unistd.h>
+#include "socket.hpp"
+
+namespace utils
+{
+	/// @brief Construct a default, invalid, socket.
+	socket_t::socket_t()
+		: socket_{INVALID_SOCKET}
+	{
+	}
+
+	/// @brief Construct a socket by moving an existing one.
+	socket_t::socket_t(socket_t&& s)
+		: socket_{s.socket_}
+	{
+		s.socket_ = INVALID_SOCKET;
+	}
+
+	/// @brief Destruct the socket.
+	socket_t::~socket_t()
+	{
+		if(socket_ != INVALID_SOCKET)
+			::close(socket_);
+	}
+
+	/// @brief Test if socket is valid.
+	/// @return true if valid, false otherwise.
+	socket_t::operator bool() const
+	{
+		return socket_ != INVALID_SOCKET;
+	}
+
+	/// @brief Open the socket.
+	/// @param[in] domain Specifies the communications domain in which a socket is to be created.
+	/// @param[in] type Specifies the type of socket to be created.
+	/// @param[in] protocol Specifies a particular protocol to be used with the socket. Specifying a protocol of 0 causes socket() to use an unspecified default protocol appropriate for the requested socket type.
+	/// @return Upon successful completion, shall return a non-negative integer, the socket file descriptor. Otherwise, a value of -1 shall be returned and errno set to indicate the error.
+	int socket_t::open(int domain, int type, int protocol)
+	{
+		close();
+		socket_ = ::socket(domain, type, protocol);
+		return socket_;
+	}
+
+	/// @brief Close the socket.
+	/// @return 0 if success.
+	int socket_t::close()
+	{
+		return socket_ != INVALID_SOCKET ? ::close(socket_) : 0;
+	}
+
+	/// @brief Set socket option.
+	/// @return 0 if success.
+	int socket_t::setopt(int level, int optname, const void* optval, socklen_t optlen)
+	{
+		return socket_ != INVALID_SOCKET ? ::setsockopt(socket_, level, optname, optval, optlen) : 0;
+	}
+
+	/// @brief Bind the socket.
+	/// @return 0 if success.
+	int socket_t::bind(const struct sockaddr* addr, socklen_t len)
+	{
+		return socket_ != INVALID_SOCKET ? ::bind(socket_, addr, len) : 0;
+	}
+
+	/// @brief Get the file descriptor.
+	/// @return The socket's file descriptor
+	int socket_t::socket() const
+	{
+		return socket_;
+	}
+}
diff --git a/CAN-binder/low-can-binding/utils/socket.hpp b/CAN-binder/low-can-binding/utils/socket.hpp
new file mode 100644
index 0000000..b42eee6
--- /dev/null
+++ b/CAN-binder/low-can-binding/utils/socket.hpp
@@ -0,0 +1,46 @@
+#pragma once
+
+/*
+ * Copyright (C) 2015, 2016 ,2017 "IoT.bzh"
+ * Author "Romain Forlot" <romain.forlot@iot.bzh>
+ * Author "Loïc Collignon" <loic.collignon@iot.bzh>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <sys/socket.h>
+
+#define INVALID_SOCKET -1
+
+namespace utils
+{
+	class socket_t
+	{
+	public:
+		socket_t();
+		socket_t(const socket_t&) = delete;
+		socket_t(socket_t&&);
+		~socket_t();
+
+		explicit operator bool() const;
+
+		int open(int domain, int type, int protocol);
+		int close();
+		int setopt(int level, int optname, const void* optval, socklen_t optlen);
+		int socket() const;
+		int bind(const struct sockaddr* addr, socklen_t len);
+
+	private:
+		int socket_;
+	};
+}
+
diff --git a/CAN-binder/low-can-binding/utils/timer.cpp b/CAN-binder/low-can-binding/utils/timer.cpp
new file mode 100644
index 0000000..a35a3e9
--- /dev/null
+++ b/CAN-binder/low-can-binding/utils/timer.cpp
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2015, 2016 "IoT.bzh"
+ * Author "Romain Forlot" <romain.forlot@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <time.h>
+#include <stdlib.h> 
+
+#include "timer.hpp"
+
+long long int system_time_us()
+{
+	struct timespec t_usec;
+	long long int timestamp_usec;
+	
+	if(!::clock_gettime(CLOCK_MONOTONIC, &t_usec))
+		timestamp_usec = (t_usec.tv_nsec / 1000ll) + (t_usec.tv_sec* 1000000ll);
+	return timestamp_usec;
+}
+
+long long int system_time_ms()
+{
+	struct timespec t_msec;
+	long long int timestamp_msec;
+	
+	if(!::clock_gettime(CLOCK_MONOTONIC, &t_msec))
+		timestamp_msec = (t_msec.tv_nsec / 1000000ll) + (t_msec.tv_sec* 1000ll);
+	return timestamp_msec;
+}
+
+long long int system_time_s()
+{
+	struct timespec t_sec;
+	long long int timestamp_sec;
+	
+	if(!::clock_gettime(CLOCK_MONOTONIC, &t_sec))
+		timestamp_sec = t_sec.tv_sec;
+	return timestamp_sec;
+}
+
+frequency_clock_t::frequency_clock_t()
+	: unit_{1000000}, frequency_{10.0}, last_tick_{0}, time_function_{nullptr}
+{}
+
+
+frequency_clock_t::frequency_clock_t(float frequency)
+	: unit_{1000000}, frequency_{frequency}, last_tick_{0}, time_function_{nullptr}
+{}
+
+/// @brief Return the period in ms given the frequency in hertz.
+/// @param[in] frequency - Frequency to convert, in hertz
+float frequency_clock_t::frequency_to_period()
+{
+	return 1 / frequency_ * unit_;
+}
+
+bool frequency_clock_t::started()
+{
+	return last_tick_ != 0;
+}
+
+time_function_t frequency_clock_t::get_time_function()
+{
+	return time_function_ != nullptr ? time_function_ : system_time_us;
+}
+
+bool frequency_clock_t::elapsed(bool stagger)
+{
+	float period = frequency_to_period();
+	float elapsed_time = 0;
+	if(!started() && stagger)
+		last_tick_ = get_time_function()() - (rand() % int(period));
+
+	// Make sure it ticks the the first call
+	elapsed_time = !started() ? period : get_time_function()() - last_tick_;
+
+	return frequency_ == 0 || elapsed_time >= period;
+}
+
+float frequency_clock_t::get_frequency() const
+{
+	return frequency_;
+}
+
+/// @brief Force the clock to tick, regardless of it its time has actually
+/// elapsed.
+void frequency_clock_t::tick()
+{
+	last_tick_ = get_time_function()();
+}
\ No newline at end of file
diff --git a/CAN-binder/low-can-binding/utils/timer.hpp b/CAN-binder/low-can-binding/utils/timer.hpp
new file mode 100644
index 0000000..f565904
--- /dev/null
+++ b/CAN-binder/low-can-binding/utils/timer.hpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2015, 2016 "IoT.bzh"
+ * Author "Romain Forlot" <romain.forlot@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+/// @brief return epoch in milliseconds
+///
+/// @return long long int epoch in milliseconds
+typedef long long int (*time_function_t)();
+
+long long int system_time_us();
+long long int system_time_ms();
+long long int system_time_s();
+
+
+/// @brief A frequency counting clock.
+/// Utility class allowing some time function.
+class frequency_clock_t
+{
+private:
+	float unit_; ///< unit_ - multiplicator to make operation to be in the right unit (milli, micro, nano, etc)
+	float frequency_; ///< the clock frequency in Hz.
+	unsigned long last_tick_; ///< the last time (in milliseconds since startup) that the clock ticked.
+	time_function_t time_function_; ///<  a function returning current time
+
+public:
+	frequency_clock_t();
+	frequency_clock_t(float frequency);
+	frequency_clock_t(float frequency, unsigned long last_tick, time_function_t time_function);
+
+	float get_frequency() const;
+
+	float frequency_to_period();
+	bool started();
+	time_function_t get_time_function();
+	bool elapsed(bool stagger);
+
+	void tick();
+};
\ No newline at end of file