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>

40 files changed, 0 insertions, 5157 deletions

diff --git a/low-can-binding/CMakeLists.txt b/low-can-binding/CMakeLists.txt
deleted file mode 100644
index a1768ab..0000000
--- a/low-can-binding/CMakeLists.txt
+++ /dev/null
@@ -1,50 +0,0 @@
-###########################################################################
-# Copyright 2015, 2016, 2017 IoT.bzh
-#
-# author: Fulup Ar Foll <fulup@iot.bzh>
-# contrib: 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.
-###########################################################################
-
-# Add target to project dependency list
-PROJECT_TARGET_ADD(low-can-binding)
-
-	# Define project Targets
-	add_library(${TARGET_NAME} MODULE ${TARGET_NAME}.cpp configuration.cpp configuration-generated.cpp
-		can/can-bus.cpp can/can-bus-dev.cpp can/can-message-set.cpp can/can-message-definition.cpp can/can-message.cpp can/can-signals.cpp can/can-decoder.cpp
-		diagnostic/diagnostic-message.cpp diagnostic/diagnostic-manager.cpp diagnostic/active-diagnostic-request.cpp
-		utils/signals.cpp utils/openxc-utils.cpp utils/timer.cpp utils/socket.cpp)
-
-	# Binder exposes a unique public entry point
-	SET_TARGET_PROPERTIES(${TARGET_NAME} PROPERTIES
-	PREFIX ""
-	LINK_FLAGS ${BINDINGS_LINK_FLAG}
-		OUTPUT_NAME ${TARGET_NAME}
-	)
-
-	# Library dependencies (include updates automatically)
-	TARGET_LINK_LIBRARIES(${TARGET_NAME}
-		openxc-message-format
-		nanopb
-		uds-c
-		isotp-c
-		bitfield-c
-		${link_libraries}
-	)
-
-	# installation directory
-	INSTALL(TARGETS ${TARGET_NAME}
-		LIBRARY DESTINATION ${BINDINGS_INSTALL_DIR})
-
-	build_widget("BINDING")
diff --git a/low-can-binding/can/can-bus-dev.cpp b/low-can-binding/can/can-bus-dev.cpp
deleted file mode 100644
index fb76498..0000000
--- a/low-can-binding/can/can-bus-dev.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
-* 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 <map>
-#include <mutex>
-#include <unistd.h>
-#include <string.h>
-#include <net/if.h>
-#include <sys/ioctl.h>
-#include <linux/can/raw.h>
-
-#include "can-bus-dev.hpp"
-
-#include "can-bus.hpp"
-#include "can-message.hpp"
-#include "../low-can-binding.hpp"
-
-/// @brief Class constructor
-///
-/// @param[in] dev_name - String representing the device name into the linux /dev tree
-/// @param[in] address - integer identifier of the bus, set using init_can_dev from can_bus_t.
-can_bus_dev_t::can_bus_dev_t(const std::string& dev_name, int32_t address)
-	: device_name_{dev_name}, address_{address}
-{}
-
-std::string can_bus_dev_t::get_device_name() const
-{
-	return device_name_;
-}
-
-uint32_t can_bus_dev_t::get_address() const
-{
-	return address_;
-}
-
-/// @brief Open the can socket and returning it
-///
-///  We try to open CAN socket and apply the following options
-///  timestamp received messages and pass the socket to FD mode.
-///
-/// @return -1 if something wrong.
-int can_bus_dev_t::open()
-{
-	const int canfd_on = 1;
-	const int timestamp_on = 1;
-	struct ifreq ifr;
-	struct timeval timeout;
-
-	DEBUG(binder_interface, "open: CAN Handler socket : %d", can_socket_.socket());
-	if (can_socket_)
-		return 0;
-
-	can_socket_.open(PF_CAN, SOCK_RAW, CAN_RAW);
-	if (can_socket_)
-	{
-		DEBUG(binder_interface, "open: CAN Handler socket correctly initialized : %d", can_socket_.socket());
-
-		// Set timeout for read
-		can_socket_.setopt(SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
-
-		// Set timestamp for receveid frame
-		if (can_socket_.setopt(SOL_SOCKET, SO_TIMESTAMP, &timestamp_on, sizeof(timestamp_on)) < 0)
-			WARNING(binder_interface, "open: setsockopt SO_TIMESTAMP error: %s", ::strerror(errno));
-		DEBUG(binder_interface, "open: Switch CAN Handler socket to use fd mode");
-
-		// try to switch the socket into CAN_FD mode
-		if (can_socket_.setopt(SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on)) < 0)
-		{
-			NOTICE(binder_interface, "open: Can not switch into CAN Extended frame format.");
-			is_fdmode_on_ = false;
-		}
-		else
-		{
-			DEBUG(binder_interface, "open: Correctly set up CAN socket to use FD frames.");
-			is_fdmode_on_ = true;
-		}
-
-		// Attempts to open a socket to CAN bus
-		::strcpy(ifr.ifr_name, device_name_.c_str());
-		DEBUG(binder_interface, "open: ifr_name is : %s", ifr.ifr_name);
-		if(::ioctl(can_socket_.socket(), SIOCGIFINDEX, &ifr) < 0)
-		{
-			ERROR(binder_interface, "open: ioctl failed. Error was : %s", strerror(errno));
-		}
-		else
-		{
-			txAddress_.can_family = AF_CAN;
-			txAddress_.can_ifindex = ifr.ifr_ifindex;
-
-			// And bind it to txAddress
-			DEBUG(binder_interface, "Bind the socket");
-			if (can_socket_.bind((struct sockaddr *)&txAddress_, sizeof(txAddress_)) < 0)
-				ERROR(binder_interface, "Bind failed. %s", strerror(errno));
-			else return 0;
-		}
-		close();
-	}
-	else ERROR(binder_interface, "open: socket could not be created. Error was : %s", ::strerror(errno));
-	return -1;
-}
-
-/// @brief Close the bus.
-///
-/// @return interger return value of socket.close() function
-int can_bus_dev_t::close()
-{
-	return can_socket_.close();
-}
-
-/// @brief Read the can socket and retrieve canfd_frame.
-///
-///  Read operation are blocking and we try to read CANFD frame
-///  rather than classic CAN frame. CANFD frame are retro compatible.
-can_message_t can_bus_dev_t::read()
-{
-	ssize_t nbytes;
-	struct canfd_frame cfd;
-
-	// Test that socket is really opened
-	if (!can_socket_)
-	{
-		ERROR(binder_interface, "read: Socket unavailable. Closing thread.");
-		is_running_ = false;
-	}
-
-	nbytes = ::read(can_socket_.socket(), &cfd, CANFD_MTU);
-
-	// if we did not fit into CAN sized messages then stop_reading.
-	if (nbytes != CANFD_MTU && nbytes != CAN_MTU)
-	{
-		if (errno == ENETDOWN)
-			ERROR(binder_interface, "read: %s CAN device down", device_name_.c_str());
-		ERROR(binder_interface, "read: Incomplete CAN(FD) frame");
-		::memset(&cfd, 0, sizeof(cfd));
-	}
-
-	DEBUG(binder_interface, "read: Found id: %X, length: %X, data %02X%02X%02X%02X%02X%02X%02X%02X", cfd.can_id, cfd.len,
-							cfd.data[0], cfd.data[1], cfd.data[2], cfd.data[3], cfd.data[4], cfd.data[5], cfd.data[6], cfd.data[7]);
-	return can_message_t::convert_from_canfd_frame(cfd, nbytes);
-}
-
-/// @brief start reading threads and set flag is_running_
-/// @param[in] can_bus reference can_bus_t. it will be passed to the thread to allow using can_bus_t queue.
-void can_bus_dev_t::start_reading(can_bus_t& can_bus)
-{
-	DEBUG(binder_interface, "Launching reading thread");
-	is_running_ = true;
-	th_reading_ = std::thread(&can_bus_dev_t::can_reader, this, std::ref(can_bus));
-	if(!th_reading_.joinable())
-		is_running_ = false;
-}
-
-/// @brief stop the reading thread setting flag is_running_ to false and and wait that the thread finish its job.
-void can_bus_dev_t::stop_reading()
-{
-	is_running_ = false;
-}
-
-/// @brief Thread function used to read the can socket.
-/// @param[in] can_bus - object to be used to read the can socket
-void can_bus_dev_t::can_reader(can_bus_t& can_bus)
-{
-	while(is_running_)
-	{
-		can_message_t msg = read();
-		{
-			std::lock_guard<std::mutex> can_message_lock(can_bus.get_can_message_mutex());
-			can_bus.push_new_can_message(msg);
-		}
-		can_bus.get_new_can_message_cv().notify_one();
-	}
-}
-
-/// @brief Send a can message from a can_message_t object.
-/// @param[in] can_msg - the can message object to send
-///
-/// @return 0 if message snet, -1 if something wrong.
-int can_bus_dev_t::send(can_message_t& can_msg)
-{
-	ssize_t nbytes;
-	canfd_frame f;
-
-	f = can_msg.convert_to_canfd_frame();
-
-	if(can_socket_)
-	{
-		nbytes = ::sendto(can_socket_.socket(), &f, sizeof(struct canfd_frame), 0,
-			(struct sockaddr*)&txAddress_, sizeof(txAddress_));
-		if (nbytes == -1)
-		{
-			ERROR(binder_interface, "send_can_message: Sending CAN frame failed.");
-			return -1;
-		}
-		return (int)nbytes;
-	}
-	else
-	{
-		ERROR(binder_interface, "send_can_message: socket not initialized. Attempt to reopen can device socket.");
-		open();
-	}
-	return 0;
-}
-
-/// @brief Static method used to send diagnostic CAN message
-/// that follow isotp SendShimsMessage signature. This method is launched
-/// from diagnostic manager's' same name method. It will use the diagnostic
-/// manager configured CAN bus device to send the CAN message.
-///
-/// @param[in] arbitration_id - CAN arbitration id.
-/// @param[in] data - CAN message payload to send
-/// @param[in] size - size of the data to send
-///
-/// @return True if message sent, false if not.
-bool can_bus_dev_t::shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size)
-{
-	ssize_t nbytes;
-	canfd_frame f;
-
-	f.can_id = arbitration_id;
-	f.len = size;
-	::memcpy(f.data, data, size);
-
-	if(can_socket_)
-	{
-		nbytes = ::sendto(can_socket_.socket(), &f, sizeof(struct canfd_frame), 0,
-			(struct sockaddr*)&txAddress_, sizeof(txAddress_));
-		if (nbytes == -1)
-		{
-			ERROR(binder_interface, "send_can_message: Sending CAN frame failed.");
-			return false;
-		}
-		return true;
-	}
-	else
-	{
-		ERROR(binder_interface, "send_can_message: socket not initialized. Attempt to reopen can device socket.");
-		open();
-	}
-	return false;
-}
diff --git a/low-can-binding/can/can-bus-dev.hpp b/low-can-binding/can/can-bus-dev.hpp
deleted file mode 100644
index a612e7d..0000000
--- a/low-can-binding/can/can-bus-dev.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-
-#include <stdint.h>
-#include <linux/can.h>
-#include <string>
-#include <thread>
-
-#include "../utils/socket.hpp"
-
-class can_bus_t;
-class can_message_t;
-
-/// @brief Object representing a can device. Handle opening, closing and reading on the
-/// socket. This is the low level object to be initialized and use by can_bus_t.
-class can_bus_dev_t
-{
-private:
-	std::string device_name_; ///< a string identifier identitfying the linux CAN device.
-	utils::socket_t can_socket_;
-
-	int32_t address_; ///< an identifier used through binding that refer to that device
-
-	bool is_fdmode_on_; ///< boolean telling if whether or not the can socket use fdmode.
-	struct sockaddr_can txAddress_; /// < internal member using to bind to the socket
-
-	std::thread th_reading_; ///< Thread handling read the socket can device filling can_message_q_ queue of can_bus_t
-	bool is_running_ = false; ///< boolean telling whether or not reading is running or not
-	void can_reader(can_bus_t& can_bus);
-
-public:
-	can_bus_dev_t(const std::string& dev_name, int32_t address);
-
-	std::string get_device_name() const;
-	uint32_t get_address() const;
-
-	int open();
-	int close();
-
-	void start_reading(can_bus_t& can_bus);
-
-	void stop_reading();
-
-	can_message_t read();
-
-	int send(can_message_t& can_msg);
-	bool shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size);
-};
diff --git a/low-can-binding/can/can-bus.cpp b/low-can-binding/can/can-bus.cpp
deleted file mode 100644
index 33f58fd..0000000
--- a/low-can-binding/can/can-bus.cpp
+++ /dev/null
@@ -1,398 +0,0 @@
-/*
- * 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 <map>
-#include <cerrno>
-#include <vector>
-#include <string>
-#include <fcntl.h>
-#include <unistd.h>
-#include <net/if.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#include <json-c/json.h>
-#include <linux/can/raw.h>
-
-#include "can-bus.hpp"
-
-#include "can-signals.hpp"
-#include "can-decoder.hpp"
-#include "../configuration.hpp"
-#include "../utils/signals.hpp"
-#include "../utils/openxc-utils.hpp"
-
-extern "C"
-{
-	#include <afb/afb-binding.h>
-}
-
-/// @brief Class constructor
-///
-/// @param[in] conf_file - handle to the json configuration file.
-can_bus_t::can_bus_t(int conf_file)
-	: conf_file_{conf_file}
-{
-}
-
-std::map<std::string, std::shared_ptr<can_bus_dev_t>> can_bus_t::can_devices_;
-
-/// @brief Will make the decoding operation on a classic CAN message. It will not
-/// handle CAN commands nor diagnostic messages that have their own method to get
-/// this happens.
-///
-/// It will add to the vehicle_message queue the decoded message and tell the event push
-/// thread to process it.
-///
-/// @param[in] can_message - a single CAN message from the CAN socket read, to be decode.
-///
-/// @return How many signals has been decoded.
-int can_bus_t::process_can_signals(can_message_t& can_message)
-{
-	int processed_signals = 0;
-	std::vector <can_signal_t*> signals;
-	openxc_DynamicField search_key, decoded_message;
-	openxc_VehicleMessage vehicle_message;
-
-	// First we have to found which can_signal_t it is
-	search_key = build_DynamicField((double)can_message.get_id());
-	configuration_t::instance().find_can_signals(search_key, signals);
-
-	// Decoding the message ! Don't kill the messenger !
-	for(auto& sig : signals)
-	{
-		std::lock_guard<std::mutex> subscribed_signals_lock(get_subscribed_signals_mutex());
-		std::map<std::string, struct afb_event>& s = get_subscribed_signals();
-
-		// DEBUG message to make easier debugger STL containers...
-		//DEBUG(binder_interface, "Operator[] key char: %s, event valid? %d", sig.generic_name, afb_event_is_valid(s[sig.generic_name]));
-		//DEBUG(binder_interface, "Operator[] key string: %s, event valid? %d", sig.generic_name, afb_event_is_valid(s[std::string(sig.generic_name)]));
-		//DEBUG(binder_interface, "Nb elt matched char: %d", (int)s.count(sig.generic_name));
-		//DEBUG(binder_interface, "Nb elt matched string: %d", (int)s.count(std::string(sig.generic_name));
-		if( s.find(sig->get_name()) != s.end() && afb_event_is_valid(s[sig->get_name()]))
-		{
-			decoded_message = decoder_t::translateSignal(*sig, can_message, configuration_t::instance().get_can_signals());
-
-			openxc_SimpleMessage s_message = build_SimpleMessage(sig->get_name(), decoded_message);
-			vehicle_message = build_VehicleMessage(s_message);
-
-			std::lock_guard<std::mutex> decoded_can_message_lock(decoded_can_message_mutex_);
-			push_new_vehicle_message(vehicle_message);
-			processed_signals++;
-		}
-	}
-
-	DEBUG(binder_interface, "process_can_signals: %d/%d CAN signals processed.", processed_signals, (int)signals.size());
-	return processed_signals;
-}
-
-/// @brief Will make the decoding operation on a diagnostic CAN message.Then it find the subscribed signal
-/// corresponding and will add the vehicle_message to the queue of event to pushed before notifying
-/// the event push thread to process it.
-///
-/// @param[in] manager - the diagnostic manager object that handle diagnostic communication
-/// @param[in] can_message - a single CAN message from the CAN socket read, to be decode.
-///
-/// @return How many signals has been decoded.
-int can_bus_t::process_diagnostic_signals(diagnostic_manager_t& manager, const can_message_t& can_message)
-{
-	int processed_signals = 0;
-
-	std::lock_guard<std::mutex> subscribed_signals_lock(get_subscribed_signals_mutex());
-	std::map<std::string, struct afb_event>& s = get_subscribed_signals();
-
-	openxc_VehicleMessage vehicle_message = manager.find_and_decode_adr(can_message);
-	if( (vehicle_message.has_simple_message && vehicle_message.simple_message.has_name) &&
-		(s.find(vehicle_message.simple_message.name) != s.end() && afb_event_is_valid(s[vehicle_message.simple_message.name])))
-	{
-		std::lock_guard<std::mutex> decoded_can_message_lock(decoded_can_message_mutex_);
-		push_new_vehicle_message(vehicle_message);
-		processed_signals++;
-	}
-
-	return processed_signals;
-}
-
-/// @brief thread to decoding raw CAN messages.
-///
-///  Depending on the nature of message, if arbitration ID matches ID for a diagnostic response
-///  then decoding a diagnostic message else use classic CAN signals decoding functions.
-///
-/// It will take from the can_message_q_ queue the next can message to process then it search
-///  about signal subscribed if there is a valid afb_event for it. We only decode signal for which a
-///  subscription has been made. Can message will be decoded using translateSignal that will pass it to the
-///  corresponding decoding function if there is one assigned for that signal. If not, it will be the default
-///  noopDecoder function that will operate on it.
-///
-///  TODO: make diagnostic messages parsing optionnal.
-void can_bus_t::can_decode_message()
-{
-	can_message_t can_message;
-
-	while(is_decoding_)
-	{
-		{
-			std::unique_lock<std::mutex> can_message_lock(can_message_mutex_);
-			new_can_message_cv_.wait(can_message_lock);
-			while(!can_message_q_.empty())
-			{
-				can_message = next_can_message();
-
-				if(configuration_t::instance().get_diagnostic_manager().is_diagnostic_response(can_message))
-					process_diagnostic_signals(configuration_t::instance().get_diagnostic_manager(), can_message);
-				else
-					process_can_signals(can_message);
-			}
-		}
-		new_decoded_can_message_.notify_one();
-	}
-}
-
-/// @brief thread to push events to suscribers. It will read subscribed_signals map to look
-/// which are events that has to be pushed.
-void can_bus_t::can_event_push()
-{
-	openxc_VehicleMessage v_message;
-	openxc_SimpleMessage s_message;
-	json_object* jo;
-
-	while(is_pushing_)
-	{
-		std::unique_lock<std::mutex> decoded_can_message_lock(decoded_can_message_mutex_);
-		new_decoded_can_message_.wait(decoded_can_message_lock);
-		while(!vehicle_message_q_.empty())
-		{
-			v_message = next_vehicle_message();
-
-			s_message = get_simple_message(v_message);
-			{
-				std::lock_guard<std::mutex> subscribed_signals_lock(get_subscribed_signals_mutex());
-				std::map<std::string, struct afb_event>& s = get_subscribed_signals();
-				if(s.find(std::string(s_message.name)) != s.end() && afb_event_is_valid(s[std::string(s_message.name)]))
-				{
-					jo = json_object_new_object();
-					jsonify_simple(s_message, jo);
-					if(afb_event_push(s[std::string(s_message.name)], jo) == 0)
-						on_no_clients(std::string(s_message.name));
-				}
-			}
-		}
-	}
-}
-
-/// @brief Will initialize threads that will decode
-///  and push subscribed events.
-void can_bus_t::start_threads()
-{
-	is_decoding_ = true;
-	th_decoding_ = std::thread(&can_bus_t::can_decode_message, this);
-	if(!th_decoding_.joinable())
-		is_decoding_ = false;
-
-	is_pushing_ = true;
-	th_pushing_ = std::thread(&can_bus_t::can_event_push, this);
-	if(!th_pushing_.joinable())
-		is_pushing_ = false;
-}
-
-/// @brief Will stop all threads holded by can_bus_t object
-///  which are decoding and pushing then will wait that's
-/// they'll finish their job.
-void can_bus_t::stop_threads()
-{
-	is_decoding_ = false;
-	is_pushing_ = false;
-}
-
-/// @brief Will initialize can_bus_dev_t objects after reading
-/// the configuration file passed in the constructor. All CAN buses
-/// Initialized here will be added to a vector holding them for
-/// inventory and later access.
-///
-/// That will initialize CAN socket reading too using a new thread.
-///
-/// @return 0 if ok, other if not.
-int can_bus_t::init_can_dev()
-{
-	std::vector<std::string> devices_name;
-	int i = 0;
-	size_t t;
-
-	devices_name = read_conf();
-
-	if (! devices_name.empty())
-	{
-		t = devices_name.size();
-
-		for(const auto& device : devices_name)
-		{
-			can_bus_t::can_devices_[device] = std::make_shared<can_bus_dev_t>(device, i);
-			if (can_bus_t::can_devices_[device]->open() == 0)
-			{
-				DEBUG(binder_interface, "Start reading thread");
-				NOTICE(binder_interface, "%s device opened and reading", device.c_str());
-				can_bus_t::can_devices_[device]->start_reading(*this);
-				i++;
-			}
-			else
-			{
-				ERROR(binder_interface, "Can't open device %s", device.c_str());
-				return 1;
-			}
-		}
-
-		NOTICE(binder_interface, "Initialized %d/%d can bus device(s)", i, (int)t);
-		return 0;
-	}
-	ERROR(binder_interface, "init_can_dev: Error at CAN device initialization. No devices read from configuration file. Did you specify canbus JSON object ?");
-	return 1;
-}
-
-/// @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.
-std::vector<std::string> can_bus_t::read_conf()
-{
-	std::vector<std::string> ret;
-	json_object *jo, *canbus;
-	int n, i;
-	const char* taxi;
-
-	FILE *fd = fdopen(conf_file_, "r");
-	if (fd)
-	{
-		std::string fd_conf_content;
-		std::fseek(fd, 0, SEEK_END);
-		fd_conf_content.resize(std::ftell(fd));
-		std::rewind(fd);
-		std::fread(&fd_conf_content[0], 1, fd_conf_content.size(), fd);
-		std::fclose(fd);
-
-		DEBUG(binder_interface, "Configuration file content : %s", fd_conf_content.c_str());
-		jo = json_tokener_parse(fd_conf_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.");
-			ret.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);
-			ret.push_back(std::string(taxi));
-		}
-		else
-		{
-			n = json_object_array_length(canbus);
-			for (i = 0 ; i < n ; i++)
-				ret.push_back(json_object_get_string(json_object_array_get_idx(canbus, i)));
-		}
-		return ret;
-	}
-	ERROR(binder_interface, "Problem at reading the conf file");
-	ret.clear();
-	return ret;
-}
-
-/// @brief return new_can_message_cv_ member
-///
-/// @return  return new_can_message_cv_ member
-std::condition_variable& can_bus_t::get_new_can_message_cv()
-{
-	return new_can_message_cv_;
-}
-
-/// @brief return can_message_mutex_ member
-///
-/// @return  return can_message_mutex_ member
-std::mutex& can_bus_t::get_can_message_mutex()
-{
-	return can_message_mutex_;
-}
-
-/// @brief Return first can_message_t on the queue
-///
-/// @return a can_message_t
-can_message_t can_bus_t::next_can_message()
-{
-	can_message_t can_msg;
-
-	if(!can_message_q_.empty())
-	{
-		can_msg = can_message_q_.front();
-		can_message_q_.pop();
-		DEBUG(binder_interface, "next_can_message: Here is the next can message : id %X, length %X, data %02X%02X%02X%02X%02X%02X%02X%02X", can_msg.get_id(), can_msg.get_length(),
-			can_msg.get_data()[0], can_msg.get_data()[1], can_msg.get_data()[2], can_msg.get_data()[3], can_msg.get_data()[4], can_msg.get_data()[5], can_msg.get_data()[6], can_msg.get_data()[7]);
-		return can_msg;
-	}
-
-	return can_msg;
-}
-
-/// @brief Push a can_message_t into the queue
-///
-/// @param[in] can_msg - the const reference can_message_t object to push into the queue
-void can_bus_t::push_new_can_message(const can_message_t& can_msg)
-{
-	can_message_q_.push(can_msg);
-}
-
-/// @brief Return first openxc_VehicleMessage on the queue
-///
-/// @return a openxc_VehicleMessage containing a decoded can message
-openxc_VehicleMessage can_bus_t::next_vehicle_message()
-{
-	openxc_VehicleMessage v_msg;
-
-	if(! vehicle_message_q_.empty())
-	{
-		v_msg = vehicle_message_q_.front();
-		vehicle_message_q_.pop();
-		DEBUG(binder_interface, "next_vehicle_message: next vehicle message poped");
-		return v_msg;
-	}
-
-	return v_msg;
-}
-
-/// @brief Push a openxc_VehicleMessage into the queue
-///
-/// @param[in] v_msg - const reference openxc_VehicleMessage object to push into the queue
-void can_bus_t::push_new_vehicle_message(const openxc_VehicleMessage& v_msg)
-{
-	vehicle_message_q_.push(v_msg);
-}
-
-/// @brief Return a map with the can_bus_dev_t initialized
-///
-/// @return map can_bus_dev_m_ map
-const std::map<std::string, std::shared_ptr<can_bus_dev_t>>& can_bus_t::get_can_devices() const
-{
-	return can_bus_t::can_devices_;
-}
-
-/// @brief Return the shared pointer on the can_bus_dev_t initialized 
-/// with device_name "bus"
-///
-/// @param[in] bus - CAN bus device name to retrieve.
-///
-/// @return A shared pointer on an object can_bus_dev_t
-std::shared_ptr<can_bus_dev_t> can_bus_t::get_can_device(std::string bus)
-{
-	return can_bus_t::can_devices_[bus];
-}
diff --git a/low-can-binding/can/can-bus.hpp b/low-can-binding/can/can-bus.hpp
deleted file mode 100644
index eb47476..0000000
--- a/low-can-binding/can/can-bus.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-
-#include <mutex>
-#include <queue>
-#include <thread>
-#include <linux/can.h>
-#include <condition_variable>
-
-#include "openxc.pb.h"
-#include "can-message.hpp"
-#include "can-bus-dev.hpp"
-#include "../diagnostic/active-diagnostic-request.hpp"
-
-#include "../low-can-binding.hpp"
-
-// TODO actual max is 32 but dropped to 24 for memory considerations
-#define MAX_ACCEPTANCE_FILTERS 24
-// TODO this takes up a ton of memory
-#define MAX_DYNAMIC_MESSAGE_COUNT 12
-
-#define CAN_ACTIVE_TIMEOUT_S 30
-
-/// @brief Object used to handle decoding and manage event queue to be pushed.
-///
-/// This object is also used to initialize can_bus_dev_t object after reading
-/// json conf file describing the CAN devices to use. Thus, those object will read
-/// on the device the CAN frame and push them into the can_bus_t can_message_q_ queue.
-///
-/// That queue will be later used to be decoded and pushed to subscribers.
-class can_bus_t
-{
-private:
-	int conf_file_; ///< configuration file handle used to initialize can_bus_dev_t objects.
-
-	void can_decode_message();
-	std::thread th_decoding_; ///< thread that'll handle decoding a can frame
-	bool is_decoding_ = false; ///< boolean member controling thread while loop
-
-	void can_event_push();
-	std::thread th_pushing_; ///< thread that'll handle pushing decoded can frame to subscribers
-	bool is_pushing_ = false; ///< boolean member controling thread while loop
-
-	std::condition_variable new_can_message_cv_; ///< condition_variable use to wait until there is a new CAN message to read
-	std::mutex can_message_mutex_; ///< mutex protecting the can_message_q_ queue.
-	std::queue <can_message_t> can_message_q_; ///< queue that'll store can_message_t to decoded
-
-	std::condition_variable new_decoded_can_message_; ///< condition_variable use to wait until there is a new vehicle message to read from the queue vehicle_message_q_
-	std::mutex decoded_can_message_mutex_;  ///< mutex protecting the vehicle_message_q_ queue.
-	std::queue <openxc_VehicleMessage> vehicle_message_q_; ///< queue that'll store openxc_VehicleMessage to pushed
-
-	static std::map<std::string, std::shared_ptr<can_bus_dev_t>> can_devices_; ///< Can device map containing all can_bus_dev_t objects initialized during init_can_dev function
-
-public:
-	can_bus_t(int conf_file);
-	can_bus_t(can_bus_t&&);
-
-	int init_can_dev();
-	std::vector<std::string> read_conf();
-
-	void start_threads();
-	void stop_threads();
-
-	int process_can_signals(can_message_t& can_message);
-	int process_diagnostic_signals(diagnostic_manager_t& manager, const can_message_t& can_message);
-
-	can_message_t next_can_message();
-	void push_new_can_message(const can_message_t& can_msg);
-	std::mutex& get_can_message_mutex();
-	std::condition_variable& get_new_can_message_cv();
-
-	openxc_VehicleMessage next_vehicle_message();
-	void push_new_vehicle_message(const openxc_VehicleMessage& v_msg);
-
-	const std::map<std::string, std::shared_ptr<can_bus_dev_t>>& get_can_devices() const;
-	static std::shared_ptr<can_bus_dev_t> get_can_device(std::string bus);
-};
diff --git a/low-can-binding/can/can-command.hpp b/low-can-binding/can/can-command.hpp
deleted file mode 100644
index 4cf20cb..0000000
--- a/low-can-binding/can/can-command.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * 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 "openxc.pb.h"
-#include "can-signals.hpp"
-
-///
-/// @brief The type signature for a function to handle a custom OpenXC command.
-///
-/// @param[in] name - the name of the received command.
-/// @param[in] value - the value of the received command, in a DynamicField. The actual type
-///		may be a number, string or bool.
-/// @param[in] event - an optional event from the received command, in a DynamicField. The
-///		actual type may be a number, string or bool.
-/// @param[in] signals - The list of all signals.
-/// @param[in] signalCount - The length of the signals array.
-///
-typedef void (*CommandHandler)(const char* name, openxc_DynamicField* value,
-		openxc_DynamicField* event, can_signal_t* signals, int signalCount);
-
-/// @struct CanCommand
-/// @brief The structure to represent a supported custom OpenXC command.
-///
-/// For completely customized CAN commands without a 1-1 mapping between an
-/// OpenXC message from the host and a CAN signal, you can define the name of the
-/// command and a custom function to handle it in the VI. An example is
-/// the "turn_signal_status" command in OpenXC, which has a value of "left" or
-/// "right". The vehicle may have separate CAN signals for the left and right
-/// turn signals, so you will need to implement a custom command handler to send
-/// the correct signals.
-///
-/// Command handlers are also useful if you want to trigger multiple CAN messages
-/// or signals from a signal OpenXC message.
-///
-typedef struct {
-	const char* generic_name; /*!< generic_name - The name of the command.*/
-	CommandHandler handler; /*!< handler - An function to process the received command's data and perform some
- 							 *	action.*/
-} CanCommand;
diff --git a/low-can-binding/can/can-decoder.cpp b/low-can-binding/can/can-decoder.cpp
deleted file mode 100644
index 8843059..0000000
--- a/low-can-binding/can/can-decoder.cpp
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
- * 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 "can-decoder.hpp"
-
-#include "canutil/read.h"
-#include "../utils/openxc-utils.hpp"
-
-/// @brief Parse the signal's bitfield from the given data and return the raw
-/// value.
-///
-/// @param[in] signal - The signal to parse from the data.
-/// @param[in] message - can_message_t to parse
-///
-/// @return Returns the raw value of the signal parsed as a bitfield from the given byte
-/// array.
-///
-float decoder_t::parseSignalBitfield(can_signal_t& signal, const can_message_t& message)
-{
-	 return bitfield_parse_float(message.get_data(), CAN_MESSAGE_SIZE,
-			signal.get_bit_position(), signal.get_bit_size(), signal.get_factor(),
-			signal.get_offset());
-}
-
-/// @brief Wrap a raw CAN signal value in a DynamicField without modification.
-///
-/// This is an implementation of the SignalDecoder type signature, and can be
-/// used directly in the can_signal_t.decoder field.
-///
-/// @param[in] signal - The details of the signal that contains the state mapping.
-/// @param[in] signals - The list of all signals
-/// @param[in] value - The numerical value that will be wrapped in a DynamicField.
-/// @param[out] send - An output argument that will be set to false if the value should
-///     not be sent for any reason.
-///
-/// @return Returns a DynamicField with the original, unmodified raw CAN signal value as
-/// its numeric value. The 'send' argument will not be modified as this decoder
-/// always succeeds.
-///
-openxc_DynamicField decoder_t::noopDecoder(can_signal_t& signal,
-		const std::vector<can_signal_t>& signals, float value, bool* send)
-{
-	openxc_DynamicField decoded_value = build_DynamicField(value);
-
-	return decoded_value;
-}
-/// @brief Coerces a numerical value to a boolean.
-///
-/// This is an implementation of the SignalDecoder type signature, and can be
-/// used directly in the can_signal_t.decoder field.
-///
-/// @param[in] signal  - The details of the signal that contains the state mapping.
-/// @param[in] signals - The list of all signals
-/// @param[in] value - The numerical value that will be converted to a boolean.
-/// @param[out] send - An output argument that will be set to false if the value should
-///     not be sent for any reason.
-///
-/// @return Returns a DynamicField with a boolean value of false if the raw signal value
-/// is 0.0, otherwise true. The 'send' argument will not be modified as this
-/// decoder always succeeds.
-///
-openxc_DynamicField decoder_t::booleanDecoder(can_signal_t& signal,
-		const std::vector<can_signal_t>& signals, float value, bool* send)
-{
-	openxc_DynamicField decoded_value = build_DynamicField(value == 0.0 ? false : true);
-
-	return decoded_value;
-}
-/// @brief Update the metadata for a signal and the newly received value.
-///
-/// This is an implementation of the SignalDecoder type signature, and can be
-/// used directly in the can_signal_t.decoder field.
-///
-/// This function always flips 'send' to false.
-///
-/// @param[in] signal  - The details of the signal that contains the state mapping.
-/// @param[in] signals - The list of all signals.
-/// @param[in] value - The numerical value that will be converted to a boolean.
-/// @param[out] send - This output argument will always be set to false, so the caller will
-///      know not to publish this value to the pipeline.
-///
-/// @return Return value is undefined.
-///
-openxc_DynamicField decoder_t::ignoreDecoder(can_signal_t& signal,
-		const std::vector<can_signal_t>& signals, float value, bool* send)
-{
-	if(send)
-	  *send = false;
-
-	openxc_DynamicField decoded_value;
-
-	return decoded_value;
-}
-
-/// @brief Find and return the corresponding string state for a CAN signal's
-/// raw integer value.
-///
-/// This is an implementation of the SignalDecoder type signature, and can be
-/// used directly in the can_signal_t.decoder field.
-///
-/// @param[in] signal  - The details of the signal that contains the state mapping.
-/// @param[in] signals - The list of all signals.
-/// @param[in] value - The numerical value that should map to a state.
-/// @param[out] send - An output argument that will be set to false if the value should
-///     not be sent for any reason.
-///
-/// @return Returns a DynamicField with a string value if a matching state is found in
-/// the signal. If an equivalent isn't found, send is sent to false and the
-/// return value is undefined.
-///
-openxc_DynamicField decoder_t::stateDecoder(can_signal_t& signal,
-		const std::vector<can_signal_t>& signals, float value, bool* send)
-{
-	const std::string signal_state = signal.get_states((uint8_t)value);
-	openxc_DynamicField decoded_value = build_DynamicField(signal_state);
-	if(signal_state.size() <= 0)
-	{
-		*send = false;
-		ERROR(binder_interface, "stateDecoder: No state found with index: %d", (int)value);
-	}
-	return decoded_value;
-}
-
-
-/// @brief Parse a signal from a CAN message, apply any required transforations
-///      to get a human readable value and public the result to the pipeline.
-///
-/// If the can_signal_t has a non-NULL 'decoder' field, the raw CAN signal value
-/// will be passed to the decoder before publishing.
-///
-/// @param[in] signal - The details of the signal to decode and forward.
-/// @param[in] message - The received CAN message that should contain this signal.
-/// @param[in] signals - an array of all active signals.
-///
-/// The decoder returns an openxc_DynamicField, which may contain a number,
-/// string or boolean.
-///
-openxc_DynamicField decoder_t::translateSignal(can_signal_t& signal, can_message_t& message,
-	const std::vector<can_signal_t>& signals)
-{
-	float value = decoder_t::parseSignalBitfield(signal, message);
-	DEBUG(binder_interface, "translateSignal: Decoded message from parseSignalBitfield: %f", value);
-
-	bool send = true;
-	// Must call the decoders every time, regardless of if we are going to
-	// decide to send the signal or not.
-	openxc_DynamicField decoded_value = decoder_t::decodeSignal(signal,
-			value, signals, &send);
-
-	signal.set_received(true);
-	signal.set_last_value(value);
-	return decoded_value;
-}
-
-/// @brief Parse a signal from a CAN message and apply any required
-/// transforations to get a human readable value.
-///
-/// If the can_signal_t has a non-NULL 'decoder' field, the raw CAN signal value
-/// will be passed to the decoder before returning.
-///
-/// @param[in] signal - The details of the signal to decode and forward.
-/// @param[in] value - The numerical value that will be converted to a boolean.
-/// @param[in] signals - an array of all active signals.
-/// @param[out] send - An output parameter that will be flipped to false if the value could
-///      not be decoded.
-///
-/// @return The decoder returns an openxc_DynamicField, which may contain a number,
-/// string or boolean. If 'send' is false, the return value is undefined.
-///
-openxc_DynamicField decoder_t::decodeSignal( can_signal_t& signal,
-		float value, const std::vector<can_signal_t>& signals, bool* send)
-{
-	SignalDecoder decoder = signal.get_decoder() == nullptr ?
-							noopDecoder : signal.get_decoder();
-	openxc_DynamicField decoded_value = decoder(signal, signals,
-			value, send);
-	return decoded_value;
-}
-
-/// @brief Decode a transformed, human readable value from an raw CAN signal
-/// already parsed from a CAN message.
-///
-/// This is the same as decodeSignal but you must parse the bitfield value of the signal from the CAN
-/// message yourself. This is useful if you need that raw value for something
-/// else.
-///
-/// @param[in] signal - The details of the signal to decode and forward.
-/// @param[in] message - Raw CAN message to decode
-/// @param[in] signals - an array of all active signals.
-/// @param[out] send - An output parameter that will be flipped to false if the value could
-///      not be decoded.
-///
-openxc_DynamicField decoder_t::decodeSignal( can_signal_t& signal,
-		const can_message_t& message, const std::vector<can_signal_t>& signals, bool* send)
-{
-	float value = parseSignalBitfield(signal, message);
-	return decodeSignal(signal, value, signals, send);
-}
-
-
-///
-/// @brief Decode the payload of an OBD-II PID.
-///
-/// This function matches the type signature for a DiagnosticResponseDecoder, so
-/// it can be used as the decoder for a DiagnosticRequest. It returns the decoded
-/// value of the PID, using the standard formulas (see
-/// http://en.wikipedia.org/wiki/OBD-II_PIDs#Mode_01).
-///
-/// @param[in] response - the received DiagnosticResponse (the data is in response.payload,
-///  a byte array). This is most often used when the byte order is
-///  signiticant, i.e. with many OBD-II PID formulas.
-/// @param[in] parsed_payload - the entire payload of the response parsed as an int.
-///
-/// @return Float decoded value.
-///
-float decoder_t::decode_obd2_response(const DiagnosticResponse* response, float parsed_payload)
-{
-	return diagnostic_decode_obd2_pid(response);
-}
\ No newline at end of file
diff --git a/low-can-binding/can/can-decoder.hpp b/low-can-binding/can/can-decoder.hpp
deleted file mode 100644
index ebe1de2..0000000
--- a/low-can-binding/can/can-decoder.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * 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 "can-signals.hpp"
-#include "can-message.hpp"
-#include "openxc.pb.h"
-
-class decoder_t
-{
-public:
-	static float parseSignalBitfield(can_signal_t& signal, const can_message_t& message);
-
-	static openxc_DynamicField stateDecoder(can_signal_t& signal, const std::vector<can_signal_t>& signals,
-			float value, bool* send);
-	static openxc_DynamicField booleanDecoder(can_signal_t& signal, const std::vector<can_signal_t>& signals,
-			float value, bool* send);
-	static openxc_DynamicField ignoreDecoder(can_signal_t& signal, const std::vector<can_signal_t>& signals,
-			float value, bool* send);
-	static openxc_DynamicField noopDecoder(can_signal_t& signal, const std::vector<can_signal_t>& signals,
-			float value, bool* send);
-
-	static openxc_DynamicField translateSignal(can_signal_t& signal, can_message_t& message,
-		const std::vector<can_signal_t>& signals);
-
-	static openxc_DynamicField decodeSignal(can_signal_t& signal, const can_message_t& message,
-			const std::vector<can_signal_t>& signals, bool* send);
-
-	static openxc_DynamicField decodeSignal(can_signal_t& signal, float value,
-		const std::vector<can_signal_t>& signals, bool* send);
-
-	static float decode_obd2_response(const DiagnosticResponse* response, float parsed_payload);
-
-};
\ No newline at end of file
diff --git a/low-can-binding/can/can-message-definition.cpp b/low-can-binding/can/can-message-definition.cpp
deleted file mode 100644
index 206d0b0..0000000
--- a/low-can-binding/can/can-message-definition.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * 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 "can-message-definition.hpp"
-
-can_message_definition_t::can_message_definition_t(std::uint8_t message_set_id, const std::string bus)
-	: message_set_id_{message_set_id}, bus_{bus}, last_value_{CAN_MESSAGE_SIZE}
-{}
-
-can_message_definition_t::can_message_definition_t(std::uint8_t message_set_id,
-	const std::string bus,
-	uint32_t id,
-	frequency_clock_t frequency_clock,
-	bool force_send_changed)
-	: message_set_id_{message_set_id},
-	  bus_{bus},
-	  id_{id},
-	  frequency_clock_{frequency_clock},
-	  force_send_changed_{force_send_changed},
-	  last_value_{CAN_MESSAGE_SIZE}
-{}
-
-can_message_definition_t::can_message_definition_t(std::uint8_t message_set_id,
-	const std::string bus,
-	uint32_t id,
-	can_message_format_t format,
-	frequency_clock_t frequency_clock,
-	bool force_send_changed)
-	: message_set_id_{message_set_id},
-	bus_{bus},
-	id_{id},
-	format_{format},
-	frequency_clock_{frequency_clock},
-	force_send_changed_{force_send_changed},
-	last_value_{CAN_MESSAGE_SIZE}
-{}
-
-uint32_t can_message_definition_t::get_id() const
-{
-	return id_;
-}
\ No newline at end of file
diff --git a/low-can-binding/can/can-message-definition.hpp b/low-can-binding/can/can-message-definition.hpp
deleted file mode 100644
index 98cb2c5..0000000
--- a/low-can-binding/can/can-message-definition.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * @class can_message_definition_t
- *
- * @brief The definition of a CAN message. This includes a lot of metadata, so
- * to save memory this struct should not be used for storing incoming and
- * outgoing CAN messages.
- */
-
-#pragma once
-
-#include <vector>
-#include <memory>
-
-#include "can-bus-dev.hpp"
-#include "can-message.hpp"
-#include "../utils/timer.hpp"
-
-class can_message_definition_t
-{
-private:
-	std::uint8_t message_set_id_;
-	std::string bus_; /*!< bus_ - Address of CAN bus device. */
-	uint32_t id_; /*!< id_ - The ID of the message.*/
-	can_message_format_t format_; /*!< format_ - the format of the message's ID.*/
-	frequency_clock_t frequency_clock_; /*!<  clock_ - an optional frequency clock to control the output of this
-							*      message, if sent raw, or simply to mark the max frequency for custom
-							*      handlers to retrieve.*/
-	bool force_send_changed_; /*!< force_send_changed_ - If true, regardless of the frequency, it will send CAN
- 							 *	message if it has changed when using raw passthrough.*/
-	std::vector<uint8_t> last_value_; /*!< last_value_ - The last received value of the message. Defaults to undefined.
- 										  *	This is required for the forceSendChanged functionality, as the stack
- 										  *	needs to compare an incoming CAN message with the previous frame.*/
-	
-public:
-	can_message_definition_t(std::uint8_t message_set_id, const std::string bus);
-	can_message_definition_t(std::uint8_t message_set_id, const std::string bus, uint32_t id, frequency_clock_t frequency_clock, bool force_send_changed);
-	can_message_definition_t(std::uint8_t message_set_id, const std::string bus, uint32_t id, can_message_format_t format, frequency_clock_t frequency_clock, bool force_send_changed);
-
-	uint32_t get_id() const;
-};
diff --git a/low-can-binding/can/can-message-set.cpp b/low-can-binding/can/can-message-set.cpp
deleted file mode 100644
index a9f8cf2..0000000
--- a/low-can-binding/can/can-message-set.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * 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 "can-message-set.hpp"
-
-can_message_set_t::can_message_set_t(
-		uint8_t index,
-		const std::string& name,
-		uint8_t can_bus_count,
-		unsigned short can_message_count,
-		unsigned short can_signal_count,
-		unsigned short can_command_count,
-		unsigned short obd2_signal_count)
-	: index_{index}
-	, name_{name}
-	, can_bus_count_{can_bus_count}
-	, can_message_count_{can_message_count}
-	, can_signal_count_{can_signal_count}
-	, can_command_count_{can_command_count}
-	, obd2_signal_count_{obd2_signal_count}
-{
-}
diff --git a/low-can-binding/can/can-message-set.hpp b/low-can-binding/can/can-message-set.hpp
deleted file mode 100644
index 94e2d8d..0000000
--- a/low-can-binding/can/can-message-set.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-
-#include <cstdint>
-#include <string>
-
-/// @brief A parent wrapper for a particular set of CAN messages and associated
-/// CAN buses(e.g. a vehicle or program).
-class can_message_set_t
-{
-private:
-	uint8_t index_; /// < A numerical ID for the message set, ideally the index in an array for fast lookup
-	const std::string name_; /// < The name of the message set.
-	uint8_t can_bus_count_; /// < The number of CAN buses defined for this message set.
-	uint16_t can_message_count_; /// < The number of CAN messages (across all buses) defined for this message set.
-	uint16_t can_signal_count_; /// < The number of CAN signals (across all messages) defined for this message set.
-	uint16_t can_command_count_; /// < The number of CanCommmands defined for this message set.
-	uint16_t obd2_signal_count_; /// < The number of obd2 signals defined for this message set.
-
-public:
-	can_message_set_t(
-			uint8_t index,
-			const std::string& name,
-			uint8_t can_bus_count,
-			short unsigned int can_message_count,
-			short unsigned int can_signal_count,
-			short unsigned int can_command_count,
-			short unsigned int obd2_signal_count);
-
-};
diff --git a/low-can-binding/can/can-message.cpp b/low-can-binding/can/can-message.cpp
deleted file mode 100644
index f61de67..0000000
--- a/low-can-binding/can/can-message.cpp
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
- * 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 "can-message.hpp"
-
-#include <cstring>
-
-#include "../low-can-binding.hpp"
-
-///
-/// @brief Class constructor
-///
-/// Constructor about can_message_t class.
-///
-can_message_t::can_message_t()
-	: maxdlen_{0}, id_{0}, length_{0}, format_{can_message_format_t::ERROR}, rtr_flag_{false}, flags_{0}
-{}
-
-can_message_t::can_message_t(uint8_t maxdlen,
-	uint32_t id,
-	uint8_t length,
-	can_message_format_t format,
-	bool rtr_flag,
-	uint8_t flags,
-	std::vector<uint8_t> data)
-	:  maxdlen_{maxdlen},
-	id_{id},
-	length_{length},
-	format_{format},
-	rtr_flag_{rtr_flag},
-	flags_{flags},
-	data_{data}
-{}
-
-///
-/// @brief Retrieve id_ member value.
-///
-/// @return id_ class member
-///
-uint32_t can_message_t::get_id() const
-{
-	return id_;
-}
-
-///
-/// @brief Retrieve RTR flag member.
-///
-/// @return rtr_flags_ class member
-///
-bool can_message_t::get_rtr_flag_() const
-{
-	return rtr_flag_;
-}
-
-///
-/// @brief Retrieve format_ member value.
-///
-/// @return format_ class member
-///
-can_message_format_t can_message_t::get_format() const
-{
-	if (format_ != can_message_format_t::STANDARD || format_ != can_message_format_t::EXTENDED)
-		return can_message_format_t::ERROR;
-	return format_;
-}
-
-///
-/// @brief Retrieve flags_ member value.
-///
-/// @return flags_ class member
-///
-uint8_t can_message_t::get_flags() const
-{
-	return flags_;
-}
-
-///
-/// @brief Retrieve data_ member value.
-///
-/// @return pointer to the first element
-///  of class member data_
-///
-const uint8_t* can_message_t::get_data() const
-{
-	return data_.data();
-}
-
-///
-/// @brief Retrieve length_ member value.
-///
-/// @return length_ class member
-///
-uint8_t can_message_t::get_length() const
-{
-	return length_;
-}
-
-///
-/// @brief Control whether the object is correctly initialized
-///  to be sent over the CAN bus
-///
-/// @return true if object correctly initialized and false if not.
-///
-bool can_message_t::is_correct_to_send()
-{
-	if (id_ != 0 && length_ != 0 && format_ != can_message_format_t::ERROR)
-	{
-		int i;
-		for(i=0;i<CAN_MESSAGE_SIZE;i++)
-			if(data_[i] != 0)
-				return true;
-	}
-	return false;
-}
-
-///
-/// @brief Set format_ member value.
-///
-/// Preferred way to initialize these members by using
-/// convert_from_canfd_frame method.
-///
-/// @param[in] new_format - class member
-///
-void can_message_t::set_format(const can_message_format_t new_format)
-{
-	if(new_format == can_message_format_t::STANDARD || new_format == can_message_format_t::EXTENDED || new_format == can_message_format_t::ERROR)
-		format_ = new_format;
-	else
-		ERROR(binder_interface, "ERROR: Can set format, wrong format chosen");
-}
-
-///
-/// @brief Take a canfd_frame struct to initialize class members
-///
-/// This is the preferred way to initialize class members.
-///
-/// @param[in] frame - canfd_frame to convert coming from a read of CAN socket
-/// @param[in] nbytes - bytes read from socket read operation.
-///
-/// @return A can_message_t object fully initialized with canfd_frame values.
-///
-can_message_t can_message_t::convert_from_canfd_frame(const struct canfd_frame& frame, size_t nbytes)
-{
-	uint8_t maxdlen, length, flags = (uint8_t)NULL;
-	uint32_t id;
-	can_message_format_t format;
-	bool rtr_flag;
-	std::vector<uint8_t> data;
-
-	switch(nbytes)
-	{
-		case CANFD_MTU:
-			DEBUG(binder_interface, "set_max_data_length: Got an CAN FD frame");
-			maxdlen = CANFD_MAX_DLEN;
-			break;
-		case CAN_MTU:
-			DEBUG(binder_interface, "set_max_data_length: Got a legacy CAN frame");
-			maxdlen = CAN_MAX_DLEN;
-			break;
-		default:
-			ERROR(binder_interface, "set_max_data_length: unsupported CAN frame");
-			break;
-	}
-
-	if (frame.can_id & CAN_ERR_FLAG)
-		format = can_message_format_t::ERROR;
-	else if (frame.can_id & CAN_EFF_FLAG)
-		format = can_message_format_t::EXTENDED;
-	else
-		format = can_message_format_t::STANDARD;
-		
-	switch(format)
-	{
-		case can_message_format_t::STANDARD:
-			id = frame.can_id & CAN_SFF_MASK;
-			break;
-		case can_message_format_t::EXTENDED:
-			id = frame.can_id & CAN_EFF_MASK;
-			break;
-		case can_message_format_t::ERROR:
-			id = frame.can_id & (CAN_ERR_MASK|CAN_ERR_FLAG);
-			break;
-		default:
-			ERROR(binder_interface, "ERROR: Can set id, not a compatible format or format not set prior to set id.");
-			break;
-	}
-
-	/* Overwrite length_ if RTR flags is detected.
-	 * standard CAN frames may have RTR enabled. There are no ERR frames with RTR */
-	if (frame.can_id & CAN_RTR_FLAG)
-	{
-		rtr_flag = true;
-		if(frame.len && frame.len <= CAN_MAX_DLC)
-		{
-			if(rtr_flag)
-				length = frame.len& 0xF;
-			else
-			{
-				length = (frame.len > maxdlen) ? maxdlen : frame.len;
-			}
-		}
-	}
-	else
-	{
-		length = (frame.len > maxdlen) ? maxdlen : frame.len;
-
-		/* Flags field only present for CAN FD frames*/
-		if(maxdlen == CANFD_MAX_DLEN)
-				flags = frame.flags & 0xF;
-
-		if (data.capacity() < maxdlen)
-			data.reserve(maxdlen);
-				int i;
-
-			data.clear();
-			/* maxdlen_ is now set at CAN_MAX_DLEN or CANFD_MAX_DLEN, respectively 8 and 64 bytes*/
-			for(i=0;i<maxdlen;i++)
-			{
-				data.push_back(frame.data[i]);
-			};
-
-		DEBUG(binder_interface, "convert_from_canfd_frame: Found id: %X, format: %X, length: %X, data %02X%02X%02X%02X%02X%02X%02X%02X",
-								id, (uint8_t)format, length, data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
-	}
-
-	return can_message_t(maxdlen, id, length, format, rtr_flag, flags, data);
-}
-
-///
-/// @brief Take all initialized class's members and build an
-/// canfd_frame struct that can be use to send a CAN message over
-/// the bus.
-///
-/// @return canfd_frame struct built from class members.
-///
-canfd_frame can_message_t::convert_to_canfd_frame()
-{
-	canfd_frame frame;
-
-	if(is_correct_to_send())
-	{
-		frame.can_id = get_id();
-		frame.len = get_length();
-		::memcpy(frame.data, get_data(), length_);
-	}
-	else
-		ERROR(binder_interface, "can_message_t not correctly initialized to be sent");
-
-	return frame;
-}
diff --git a/low-can-binding/can/can-message.hpp b/low-can-binding/can/can-message.hpp
deleted file mode 100644
index 6fe0317..0000000
--- a/low-can-binding/can/can-message.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * 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 <cstdint>
-#include <linux/can.h>
-
-#include "../utils/timer.hpp"
-#include "can-message-set.hpp"
-
-#define CAN_MESSAGE_SIZE 8
-
-class can_bus_dev_t;
-
-/**
- * @enum can_message_format_t
- * @brief The ID format for a CAN message.
- */
-enum class can_message_format_t {
-	STANDARD, /*!< STANDARD - standard 11-bit CAN arbitration ID. */
-	EXTENDED, /*!< EXTENDED - an extended frame, with a 29-bit arbitration ID. */
-	ERROR,    /*!< ERROR - ERROR code used at initialization to signify that it isn't usable'*/
-};
-
-/**
- * @class can_message_t
- *
- * @brief A compact representation of a single CAN message, meant to be used in in/out
- * buffers.
- */
-class can_message_t {
-private:
-	uint8_t maxdlen_; /*!< maxdlen_ - Max data length deduce from number of bytes read from the socket.*/
-	uint32_t id_; /*!< id_ - The ID of the message. */
-	uint8_t length_; /*!< length_ - the length of the data array (max 8). */
-	can_message_format_t format_; /*!< format_ - the format of the message's ID.*/
-	bool rtr_flag_; /*!< rtr_flag_ - Telling if the frame has RTR flag positionned. Then frame hasn't data field*/
-	uint8_t flags_; /*!< flags_ - flags of a CAN FD frame. Needed if we catch FD frames.*/
-	std::vector<uint8_t> data_; /*!< data_ - The message's data field with a size of 8 which is the standard about CAN bus messages.*/
-
-public:
-	can_message_t();
-	can_message_t(uint8_t maxdlen, uint32_t id, uint8_t length, can_message_format_t format, bool rtr_flag_, uint8_t flags, std::vector<uint8_t> data);
-
-	uint32_t get_id() const;
-	bool get_rtr_flag_() const;
-	can_message_format_t get_format() const;
-	uint8_t get_flags() const;
-	const uint8_t* get_data() const;
-	uint8_t get_length() const;
-
-	void set_format(const can_message_format_t new_format);
-
-	bool is_correct_to_send();
-
-static can_message_t convert_from_canfd_frame(const struct canfd_frame& frame, size_t nbytes);
-	canfd_frame convert_to_canfd_frame();
-};
diff --git a/low-can-binding/can/can-signals.cpp b/low-can-binding/can/can-signals.cpp
deleted file mode 100644
index 6211fa1..0000000
--- a/low-can-binding/can/can-signals.cpp
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * 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 <fnmatch.h>
-
-#include "can-signals.hpp"
-
-#include "../configuration.hpp"
-#include "../utils/signals.hpp"
-#include "can-decoder.hpp"
-#include "../diagnostic/diagnostic-message.hpp"
-
-std::string can_signal_t::prefix_ = "messages";
-
-can_signal_t::can_signal_t(std::uint8_t message_set_id,
-	std::uint8_t message_id,
-	std::string generic_name,
-	uint8_t bit_position,
-	uint8_t bit_size,
-	float factor,
-	float offset,
-	float min_value,
-	float max_value,
-	frequency_clock_t frequency,
-	bool send_same,
-	bool force_send_changed,
-	std::map<uint8_t, std::string> states,
-	bool writable,
-	SignalDecoder decoder,
-	SignalEncoder encoder,
-	bool received)
-	: message_set_id_{ message_set_id }
-	, message_id_{ message_id }
-	, generic_name_{ generic_name }
-	, bit_position_{ bit_position }
-	, bit_size_{ bit_size }
-	, factor_{ factor }
-	, offset_{ offset }
-	, min_value_{min_value}
-	, max_value_{max_value}
-	, frequency_{frequency}
-	, send_same_{send_same}
-	, force_send_changed_{force_send_changed}
-	, states_{states}
-	, writable_{writable}
-	, decoder_{decoder}
-	, encoder_{encoder}
-	, received_{received}
-	, last_value_{.0f}
-{}
-
-
-const can_message_definition_t& can_signal_t::get_message() const
-{
-	return configuration_t::instance().get_can_message_definition(message_set_id_, message_id_);
-}
-
-const std::string& can_signal_t::get_generic_name() const
-{
-	return generic_name_;
-}
-
-const std::string can_signal_t::get_name() const
-{
-	return prefix_ + "." + generic_name_;
-}
-
-const std::string& can_signal_t::get_prefix() const
-{
-	return prefix_;
-}
-
-uint8_t can_signal_t::get_bit_position() const
-{
-	return bit_position_;
-}
-
-uint8_t can_signal_t::get_bit_size() const
-{
-	return bit_size_;
-}
-
-float can_signal_t::get_factor() const
-{
-	return factor_;
-}
-
-float can_signal_t::get_offset() const
-{
-	return offset_;
-}
-
-float can_signal_t::get_min_value() const
-{
-	return min_value_;
-}	
-
-float can_signal_t::get_max_value() const
-{
-	return max_value_;
-}
-
-frequency_clock_t& can_signal_t::get_frequency()
-{
-	return frequency_;
-}
-
-bool can_signal_t::get_send_same() const
-{
-	return send_same_;
-}
-
-bool can_signal_t::get_force_send_changed() const
-{
-	return force_send_changed_;
-}
-
-const std::map<uint8_t, std::string>& can_signal_t::get_states() const
-{
-	return states_;
-}
-
-const std::string can_signal_t::get_states(uint8_t value)
-{
-	if (value < states_.size())
-		return states_[value];
-	return std::string();
-}
-
-size_t can_signal_t::get_state_count() const
-{
-	return states_.size();
-}
-
-bool can_signal_t::get_writable() const
-{
-	return writable_;
-}
-
-SignalDecoder& can_signal_t::get_decoder()
-{
-	return decoder_;
-}
-
-SignalEncoder& can_signal_t::get_encoder()
-{
-	return encoder_;
-}
-
-bool can_signal_t::get_received() const
-{
-	return received_;
-}
-float can_signal_t::get_last_value() const
-{
-	return last_value_;
-}
-
-void can_signal_t::set_prefix(std::string val)
-{
-	prefix_ = val;
-}
-
-void can_signal_t::set_received(bool r)
-{
-	received_ = r;
-}
-
-void can_signal_t::set_last_value(float val)
-{
-	last_value_ = val;
-}
diff --git a/low-can-binding/can/can-signals.hpp b/low-can-binding/can/can-signals.hpp
deleted file mode 100644
index 34ebeeb..0000000
--- a/low-can-binding/can/can-signals.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-///
-/// 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 <map>
-#include <mutex>
-#include <queue>
-#include <vector>
-#include <string>
-
-#include "openxc.pb.h"
-#include "../utils/timer.hpp"
-#include "can-bus.hpp"
-#include "can-message.hpp"
-#include "can-message-definition.hpp"
-#include "../diagnostic/diagnostic-message.hpp"
-
-extern "C"
-{
-	#include <afb/afb-binding.h>
-	#include <afb/afb-event-itf.h>
-}
-
-#define MESSAGE_SET_ID 0
-
-class can_signal_t;
-
-///
-/// @brief The type signature for a CAN signal decoder.
-///
-/// A SignalDecoder transforms a raw floating point CAN signal into a number,
-/// string or boolean.
-///
-/// @param[in] signal - The CAN signal that we are decoding.
-/// @param[in] signals - The list of all signals.
-/// @param[in] signalCount - The length of the signals array.
-/// @param[in] value - The CAN signal parsed from the message as a raw floating point
-///	value.
-/// @param[out] send - An output parameter. If the decoding failed or the CAN signal should
-///	not send for some other reason, this should be flipped to false.
-///
-/// @return a decoded value in an openxc_DynamicField struct.
-///
-typedef openxc_DynamicField (*SignalDecoder)(can_signal_t& signal,
-		const std::vector<can_signal_t>& signals, float value, bool* send);
-
-///
-/// @brief: The type signature for a CAN signal encoder.
-///
-/// A SignalEncoder transforms a number, string or boolean into a raw floating
-/// point value that fits in the CAN signal.
-///
-/// @param[in] signal - The CAN signal to encode. 
-/// @param[in] value - The dynamic field to encode.
-/// @param[out] send - An output parameter. If the encoding failed or the CAN signal should
-/// not be encoded for some other reason, this will be flipped to false.
-///
-typedef uint64_t (*SignalEncoder)(can_signal_t* signal,
-		openxc_DynamicField* value, bool* send);
-
-class can_signal_t
-{
-private:
-	std::uint8_t message_set_id_;
-	std::uint8_t message_id_;
-	std::string generic_name_; /*!< generic_name_ - The name of the signal to be output.*/
-	static std::string prefix_; /*!< prefix_ - generic_name_ will be prefixed with it. It has to reflect the used protocol.
-						  * which make easier to sort message when the come in.*/
-	uint8_t bit_position_; /*!< bitPosition_ - The starting bit of the signal in its CAN message (assuming
-										*	non-inverted bit numbering, i.e. the most significant bit of
-										*	each byte is 0) */
-	uint8_t bit_size_; /*!< bitSize_ - The width of the bit field in the CAN message. */
-	float factor_; /*!< factor_ - The final value will be multiplied by this factor. Use 1 if you
-							*	don't need a factor. */
-	float offset_; /*!< offset_ - The final value will be added to this offset. Use 0 if you
-							*	don't need an offset. */
-	float min_value_; /*!< min_value_ - The minimum value for the processed signal.*/
-	float max_value_; /*!< max_value_ - The maximum value for the processed signal. */
-	frequency_clock_t frequency_; /*!< frequency_ - A frequency_clock_t struct to control the maximum frequency to
-								*	process and send this signal. To process every value, set the
-								*	clock's frequency to 0. */
-	bool send_same_; /*!< send_same_ - If true, will re-send even if the value hasn't changed.*/
-	bool force_send_changed_; /*!< force_send_changed_ - If true, regardless of the frequency, it will send the
-							   * value if it has changed. */
-	std::map<uint8_t, std::string> states_; /*!< states_ - A map of CAN signal state describing the mapping
-										 * between numerical and string values for valid states. */
-	bool writable_; /*!< writable - True if the signal is allowed to be written from the USB host
-					 *	back to CAN. Defaults to false.*/
-	SignalDecoder decoder_; /*!< decoder_ - An optional function to decode a signal from the bus to a human
-							 * readable value. If NULL, the default numerical decoder is used. */
-	SignalEncoder encoder_; /*!< encoder_ - An optional function to encode a signal value to be written to
-							 * CAN into a byte array. If NULL, the default numerical encoder
-							 * is used. */
-	bool received_; /*!< received_ - True if this signal has ever been received.*/
-	float last_value_; /*!< lastValue_ - The last received value of the signal. If 'received' is false,
-						*	this value is undefined. */
-
-public:
-	can_signal_t(
-		std::uint8_t message_set_id,
-		std::uint8_t message_id,
-		std::string generic_name,
-		uint8_t bit_position,
-		uint8_t bit_size,
-		float factor,
-		float offset,
-		float min_value,
-		float max_value,
-		frequency_clock_t frequency,
-		bool send_same,
-		bool force_send_changed,
-		std::map<uint8_t, std::string> states,
-		bool writable,
-		SignalDecoder decoder,
-		SignalEncoder encoder,
-		bool received);
-
-	const can_message_definition_t& get_message() const;
-	const std::string& get_generic_name() const;
-	const std::string get_name() const;
-	const std::string& get_prefix() const;
-	uint8_t get_bit_position() const;
-	uint8_t get_bit_size() const;
-	float get_factor() const;
-	float get_offset() const;
-	float get_min_value() const;
-	float get_max_value() const;
-	frequency_clock_t& get_frequency();
-	bool get_send_same() const;
-	bool get_force_send_changed() const;
-	const std::map<uint8_t, std::string>& get_states() const;
-	const std::string get_states(uint8_t value);
-	size_t get_state_count() const;
-	bool get_writable() const;
-	SignalDecoder& get_decoder();
-	SignalEncoder& get_encoder();
-	bool get_received() const;
-	float get_last_value() const;
-
-	void set_prefix(std::string val);
-	void set_received(bool r);
-	void set_last_value(float val);
-};
\ No newline at end of file
diff --git a/low-can-binding/configuration-generated.cpp b/low-can-binding/configuration-generated.cpp
deleted file mode 100644
index 2e96570..0000000
--- a/low-can-binding/configuration-generated.cpp
+++ /dev/null
@@ -1,350 +0,0 @@
-#include "configuration.hpp"
-#include "can/can-decoder.hpp"
-
-configuration_t::configuration_t()
-	: can_message_set_{{0, "example", 0, 1, 5, 0, 20}}
-	, can_message_definition_
-	{
-		{
-			can_message_definition_t(0, "can0", 0x620, can_message_format_t::STANDARD, frequency_clock_t(0.00000f), true)
-		}
-	}
-	, can_signals_
-	{
-		{
-			{
-				0,
-				0,
-				"doors.coffer.open",
-				88,
-				1,
-				0.00000f, 
-				0, 
-				0,
-				0,
-				frequency_clock_t(0.00000f),
-				true,
-				false,
-				{
-				},
-				false,
-				decoder_t::booleanDecoder,
-				nullptr,
-				false
-			},
-			{
-				0,
-				0,
-				"doors.driver.open",
-				78,
-				1,
-				0.00000f, 
-				0, 
-				0,
-				0,
-				frequency_clock_t(0.00000f),
-				true,
-				false,
-				{
-				},
-				false,
-				decoder_t::booleanDecoder,
-				nullptr,
-				false
-			},
-			{
-				0,
-				0,
-				"doors.passenger.open",
-				79,
-				1,
-				0.00000f, 
-				0, 
-				0,
-				0,
-				frequency_clock_t(0.00000f),
-				true,
-				false,
-				{
-				},
-				false,
-				decoder_t::booleanDecoder,
-				nullptr,
-				false
-			},
-			{
-				0,
-				0,
-				"doors.rearleft.open",
-				86,
-				1,
-				0.00000f, 
-				0, 
-				0,
-				0,
-				frequency_clock_t(0.00000f),
-				true,
-				false,
-				{
-				},
-				false,
-				decoder_t::booleanDecoder,
-				nullptr,
-				false
-			},
-			{
-				0,
-				0,
-				"doors.rearright.open",
-				85,
-				4,
-				0.00000f, 
-				0, 
-				0,
-				0,
-				frequency_clock_t(0.00000f),
-				true,
-				false,
-				{
-				},
-				false,
-				decoder_t::booleanDecoder,
-				nullptr,
-				false
-			}
-		}
-	}
-	, diagnostic_messages_
-	{
-		{
-			{
-				4,
-				"engine.load",
-				0,
-				0,
-				UNIT::INVALID,
-				5.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				5,
-				"engine.coolant.temperature",
-				0,
-				0,
-				UNIT::INVALID,
-				1.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				10,
-				"fuel.pressure",
-				0,
-				0,
-				UNIT::INVALID,
-				1.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				11,
-				"intake.manifold.pressure",
-				0,
-				0,
-				UNIT::INVALID,
-				1.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				12,
-				"engine.speed",
-				0,
-				0,
-				UNIT::INVALID,
-				5.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				13,
-				"vehicle.speed",
-				0,
-				0,
-				UNIT::INVALID,
-				5.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				15,
-				"intake.air.temperature",
-				0,
-				0,
-				UNIT::INVALID,
-				1.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				16,
-				"mass.airflow",
-				0,
-				0,
-				UNIT::INVALID,
-				5.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				17,
-				"throttle.position",
-				0,
-				0,
-				UNIT::INVALID,
-				5.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				31,
-				"running.time",
-				0,
-				0,
-				UNIT::INVALID,
-				1.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				45,
-				"EGR.error",
-				0,
-				0,
-				UNIT::INVALID,
-				0.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				47,
-				"fuel.level",
-				0,
-				0,
-				UNIT::INVALID,
-				1.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				51,
-				"barometric.pressure",
-				0,
-				0,
-				UNIT::INVALID,
-				1.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				76,
-				"commanded.throttle.position",
-				0,
-				0,
-				UNIT::INVALID,
-				1.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				82,
-				"ethanol.fuel.percentage",
-				0,
-				0,
-				UNIT::INVALID,
-				1.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				90,
-				"accelerator.pedal.position",
-				0,
-				0,
-				UNIT::INVALID,
-				5.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				91,
-				"hybrid.battery-pack.remaining.life",
-				0,
-				0,
-				UNIT::INVALID,
-				5.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				92,
-				"engine.oil.temperature",
-				0,
-				0,
-				UNIT::INVALID,
-				1.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				94,
-				"engine.fuel.rate",
-				0,
-				0,
-				UNIT::INVALID,
-				1.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			},
-			{
-				99,
-				"engine.torque",
-				0,
-				0,
-				UNIT::INVALID,
-				1.00000f,
-				decoder_t::decode_obd2_response,
-				nullptr,
-				true
-			}
-		}
-	}
-{
-}
-
-const std::string configuration_t::get_diagnostic_bus() const
-{
-	return "can0";
-}
-
-
diff --git a/low-can-binding/configuration.cpp b/low-can-binding/configuration.cpp
deleted file mode 100644
index 8a50cbc..0000000
--- a/low-can-binding/configuration.cpp
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * 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 "configuration.hpp"
-
-#include "utils/signals.hpp"
-#include "utils/openxc-utils.hpp"
-
-/// @brief Return singleton instance of configuration object.
-configuration_t& configuration_t::instance()
-{
-	static configuration_t config;
-	return config;
-}
-
-can_bus_t& configuration_t::get_can_bus_manager()
-{
-	return can_bus_manager_;
-}
-
-const std::map<std::string, std::shared_ptr<can_bus_dev_t>>& configuration_t::get_can_bus_devices()
-{
-	return can_bus_manager_.get_can_devices();
-}
-
-diagnostic_manager_t& configuration_t::get_diagnostic_manager()
-{
-	return diagnostic_manager_;
-}
-
-uint8_t configuration_t::get_active_message_set() const
-{
-	return active_message_set_;
-}
-
-const std::vector<can_message_set_t>& configuration_t::get_can_message_set()
-{
-	return can_message_set_;
-}
-
-std::vector<can_signal_t>& configuration_t::get_can_signals()
-{
-	return can_signals_[active_message_set_];
-}
-
-std::vector<diagnostic_message_t>& configuration_t::get_diagnostic_messages()
-{
-	return diagnostic_messages_[active_message_set_];
-}
-
-const std::vector<can_message_definition_t>& configuration_t::get_can_message_definition()
-{
-	return can_message_definition_[active_message_set_];
-}
-
-const can_message_definition_t& configuration_t::get_can_message_definition(std::uint8_t message_set_id, std::uint8_t message_id)
-{
-	return can_message_definition_[message_set_id][message_id];
-}
-
-uint32_t configuration_t::get_signal_id(diagnostic_message_t& sig) const
-{
-	return sig.get_pid();
-}
-
-uint32_t configuration_t::get_signal_id(can_signal_t& sig) const
-{
-	return sig.get_message().get_id();
-}
-
-void configuration_t::set_active_message_set(uint8_t id)
-{
-	active_message_set_ = id;
-}
-
-/// @brief return diagnostic messages name found searching through diagnostic messages list.
-///
-/// @param[in] key - can contain numeric or string value in order to search against
-///   can signals or obd2 signals name.
-/// @param[out] found_signals - Vector of signals name found.
-///
-void configuration_t::find_diagnostic_messages(const openxc_DynamicField &key, std::vector<diagnostic_message_t*>& found_signals)
-{
-	switch(key.type)
-	{
-		case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING:
-				lookup_signals_by_name(key.string_value, diagnostic_messages_[active_message_set_], found_signals);
-			break;
-		case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM:
-				lookup_signals_by_id(key.numeric_value, diagnostic_messages_[active_message_set_], found_signals);
-			break;
-		default:
-			ERROR(binder_interface, "find_diagnostic_messages: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
-			break;
-	}
-	DEBUG(binder_interface, "find_diagnostic_messages: Found %d signal(s)", (int)found_signals.size());
-}
-
-diagnostic_message_t* configuration_t::get_diagnostic_message(std::string message_name) const
-{
-	std::vector<diagnostic_message_t*> found;
-	configuration_t::instance().find_diagnostic_messages(build_DynamicField(message_name), found);
-	if(! found.empty())
-		return found.front();
-	return nullptr;
-}
-
-DiagnosticRequest* configuration_t::get_request_from_diagnostic_message(diagnostic_message_t* diag_msg) const
-{
-	return new DiagnosticRequest(diag_msg->build_diagnostic_request());
-}
-
-DiagnosticRequest* configuration_t::get_request_from_diagnostic_message(std::string message_name) const
-{
-	diagnostic_message_t* diag_msg = get_diagnostic_message(message_name);
-	if( diag_msg != nullptr)
-		return new DiagnosticRequest(diag_msg->build_diagnostic_request());
-	return nullptr;
-}
-
-/// @brief return signals name found searching through CAN signals list.
-///
-/// @param[in] key - can contain numeric or string value in order to search against
-///   can signals or obd2 signals name.
-/// @param[out] found_signals - provided vector to fill with pointer to matched signals.
-///
-void configuration_t::find_can_signals(const openxc_DynamicField& key, std::vector<can_signal_t*>& found_signals)
-{
-	switch(key.type)
-	{
-		case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING:
-			lookup_signals_by_name(std::string(key.string_value), can_signals_[active_message_set_], found_signals);
-			break;
-		case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM:
-			lookup_signals_by_id(key.numeric_value, can_signals_[active_message_set_], found_signals);
-			break;
-		default:
-			ERROR(binder_interface, "find_can_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
-			break;
-	}
-	DEBUG(binder_interface, "find_can_signals: Found %d signal(s)", (int)found_signals.size());
-}
diff --git a/low-can-binding/configuration.hpp b/low-can-binding/configuration.hpp
deleted file mode 100644
index 017b148..0000000
--- a/low-can-binding/configuration.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * 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 <map>
-#include <vector>
-#include <string>
-#include <fcntl.h>
-
-#include "can/can-bus.hpp"
-#include "can/can-signals.hpp"
-#include "can/can-message.hpp"
-#include "diagnostic/diagnostic-manager.hpp"
-
-#include "low-can-binding.hpp"
-
-///
-/// @brief Class representing a configuration attached to the binding.
-///
-/// It regroups all needed objects instance from other class
-///  that will be used along the binding life. It gets a global vision 
-///  on which signals are implemented for that binding. 
-///  Here, it is only the definition of the class with predefined accessors
-///  methods used in the binding.
-///
-///  It will be the reference point to needed objects.
-///
-class configuration_t
-{
-	private:
-		can_bus_t can_bus_manager_ = can_bus_t(
-			afb_daemon_rootdir_open_locale(
-				binder_interface->daemon, "etc/can_buses.json", O_RDONLY, NULL)); ///< instanciate the CAN bus
-				///< This will read the configuration file and initialize all CAN devices specified in it.
-		diagnostic_manager_t diagnostic_manager_; ///< Diagnostic manager use to manage diagnostic message communication.
-		uint8_t active_message_set_ = 0; ///< Which is the active message set ? Default to 0.
-
-		std::vector<can_message_set_t> can_message_set_;
-		std::vector<std::vector<can_message_definition_t>> can_message_definition_;
-		std::vector<std::vector<can_signal_t>> can_signals_;
-		std::vector<std::vector<diagnostic_message_t>> diagnostic_messages_;
-
-		configuration_t(); ///< Private constructor with implementation generated by the AGL generator.
-
-	public:
-		static configuration_t& instance();
-
-		can_bus_t& get_can_bus_manager();
-
-		const std::map<std::string, std::shared_ptr<can_bus_dev_t>>& get_can_bus_devices();
-
-		const std::string get_diagnostic_bus() const;
-
-		diagnostic_manager_t& get_diagnostic_manager() ;
-
-		uint8_t get_active_message_set() const;
-
-		const std::vector<can_message_set_t>& get_can_message_set();
-
-		std::vector<can_signal_t>& get_can_signals();
-
-		std::vector<diagnostic_message_t>& get_diagnostic_messages();
-
-		const std::vector<std::string>& get_signals_prefix() const;
-
-		const std::vector<can_message_definition_t>& get_can_message_definition();
-		const can_message_definition_t& get_can_message_definition(std::uint8_t message_set_id, std::uint8_t message_id);
-
-		uint32_t get_signal_id(diagnostic_message_t& sig) const;
-
-		uint32_t get_signal_id(can_signal_t& sig) const;
-
-		void set_active_message_set(uint8_t id);
-
-		void find_diagnostic_messages(const openxc_DynamicField &key, std::vector<diagnostic_message_t*>& found_signals);
-		diagnostic_message_t* get_diagnostic_message(std::string message_name) const;
-		DiagnosticRequest* get_request_from_diagnostic_message(diagnostic_message_t* diag_msg) const;
-		DiagnosticRequest* get_request_from_diagnostic_message(std::string message_name) const;
-
-		void find_can_signals(const openxc_DynamicField &key, std::vector<can_signal_t*>& found_signals);
-
-/*
-		/// TODO: implement this function as method into can_bus class
-		/// @brief Pre initialize actions made before CAN bus initialization
-		/// @param[in] bus A CanBus struct defining the bus's metadata
-		/// @param[in] writable Configure the controller in a writable mode. If false, it will be configured as "listen only" and will not allow writes or even CAN ACKs.
-		/// @param[in] buses An array of all CAN buses.
-		void pre_initialize(can_bus_dev_t* bus, bool writable, can_bus_dev_t* buses, const int busCount);
-		/// TODO: implement this function as method into can_bus class
-		/// @brief Post-initialize actions made after CAN bus initialization
-		/// @param[in] bus A CanBus struct defining the bus's metadata
-		/// @param[in] writable Configure the controller in a writable mode. If false, it will be configured as "listen only" and will not allow writes or even CAN ACKs.
-		/// @param[in] buses An array of all CAN buses.
-		void post_initialize(can_bus_dev_t* bus, bool writable, can_bus_dev_t* buses, const int busCount);
-		/// TODO: implement this function as method into can_bus class
-		/// @brief Check if the device is connected to an active CAN bus, i.e. it's received a message in the recent past.
-		/// @return true if a message was received on the CAN bus within CAN_ACTIVE_TIMEOUT_S seconds.
-		void logBusStatistics(can_bus_dev_t* buses, const int busCount);
-		/// TODO: implement this function as method into can_bus class
-		/// @brief Log transfer statistics about all active CAN buses to the debug log.
-		/// @param[in] buses An array of active CAN buses.
-		bool isBusActive(can_bus_dev_t* bus);
-		*/
-};
-
diff --git a/low-can-binding/diagnostic/active-diagnostic-request.cpp b/low-can-binding/diagnostic/active-diagnostic-request.cpp
deleted file mode 100644
index 7ddf1d5..0000000
--- a/low-can-binding/diagnostic/active-diagnostic-request.cpp
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * 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 <map>
-#include <fnmatch.h>
-
-#include "active-diagnostic-request.hpp"
-
-#include "../configuration.hpp"
-
-#define ERROR_PID 0xFF
-
-std::string active_diagnostic_request_t::prefix_ = "diagnostic_messages";
-
-bool active_diagnostic_request_t::operator==(const active_diagnostic_request_t& b)
-{
-	return (bus_ == b.bus_ && id_ == b.id_ && handle_ == b.handle_);
-}
-
-active_diagnostic_request_t& active_diagnostic_request_t::operator=(const active_diagnostic_request_t& adr)
-{
-	if (this != &adr)
-	{
-		bus_ = adr.bus_;
-		id_ = adr.id_;
-		handle_ = adr.handle_;
-		name_ = adr.name_;
-		decoder_ = adr.decoder_;
-		callback_ = adr.callback_;
-		recurring_ = adr.recurring_; 
-		wait_for_multiple_responses_ = adr.wait_for_multiple_responses_;
-		in_flight_ = adr.in_flight_;
-		frequency_clock_ = adr.frequency_clock_;
-		timeout_clock_ = adr.timeout_clock_;
-	}
-	
-	return *this;
-}
-
-active_diagnostic_request_t::active_diagnostic_request_t()
-	: bus_{nullptr}, id_{0}, handle_{nullptr}, name_{""},
-	  decoder_{nullptr}, callback_{nullptr}, recurring_{false}, wait_for_multiple_responses_{false},
-	  in_flight_{false}, frequency_clock_{frequency_clock_t()}, timeout_clock_{frequency_clock_t()}
-{}
-
-active_diagnostic_request_t::active_diagnostic_request_t(const std::string& bus, DiagnosticRequest* request,
-		const std::string& name, bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder,
-		const DiagnosticResponseCallback callback, float frequencyHz)
-	: bus_{bus}, id_{request->arbitration_id}, handle_{nullptr}, name_{name},
-	  decoder_{decoder}, callback_{callback}, recurring_{frequencyHz ? true : false}, wait_for_multiple_responses_{wait_for_multiple_responses},
-	  in_flight_{false}, frequency_clock_{frequency_clock_t(frequencyHz)}, timeout_clock_{frequency_clock_t(10)}
-{}
-
-uint32_t active_diagnostic_request_t::get_id() const
-{
-	return id_;
-}
-
-const std::shared_ptr<can_bus_dev_t> active_diagnostic_request_t::get_can_bus_dev() const
-{
-	return can_bus_t::get_can_device(bus_);
-}
-
-uint16_t active_diagnostic_request_t::get_pid() const
-{
-	if (handle_->request.has_pid)
-		return handle_->request.pid;
-	return ERROR_PID;
-}
-
-DiagnosticRequestHandle* active_diagnostic_request_t::get_handle()
-{
-	return handle_;
-}
-
-const std::string active_diagnostic_request_t::get_name() const
-{
-	return name_;
-}
-
-std::string& active_diagnostic_request_t::get_prefix()
-{
-	return active_diagnostic_request_t::prefix_;
-}
-
-DiagnosticResponseDecoder& active_diagnostic_request_t::get_decoder()
-{
-	return decoder_;
-}
-
-DiagnosticResponseCallback& active_diagnostic_request_t::get_callback()
-{
-	return callback_;
-}
-
-bool active_diagnostic_request_t::get_recurring() const
-{
-	return recurring_;
-}
-
-bool active_diagnostic_request_t::get_in_flight() const
-{
-	return in_flight_;
-}
-
-frequency_clock_t& active_diagnostic_request_t::get_frequency_clock()
-{
-	return frequency_clock_;
-}
-
-frequency_clock_t& active_diagnostic_request_t::get_timeout_clock()
-{
-	return timeout_clock_;
-}
-
-void active_diagnostic_request_t::set_handle(DiagnosticShims& shims, DiagnosticRequest* request)
-{
-	handle_ = new DiagnosticRequestHandle(generate_diagnostic_request(&shims, request, nullptr));
-}
-
-void active_diagnostic_request_t::set_in_flight(bool val)
-{
-	in_flight_ = val;
-}
-
-///
-/// @brief Check if requested signal name is a diagnostic message. If the name
-///  begin with the diagnostic message prefix then true else false.
-///
-/// @param[in] name - A signal name.
-///
-/// @return true if name began with the diagnostic message prefix else false.
-///
-bool active_diagnostic_request_t::is_diagnostic_signal(const std::string& name)
-{
-	const std::string p = active_diagnostic_request_t::prefix_ + "*";
-	if(::fnmatch(p.c_str(), name.c_str(), FNM_CASEFOLD) == 0)
-		return true;
-	return false;
-}
-
-/// @brief Check is the request should be sent or not
-///
-/// @return true if the request is not running or recurring nor completed,
-/// or it's recurring, its clock elapsed
-/// so it's time to send another one.
-bool active_diagnostic_request_t::should_send()
-{
-	return !in_flight_ && ( (!recurring_ && !request_completed()) ||
-			(recurring_ && frequency_clock_.elapsed(true)) );
-}
-
-/// @brief check if the timeout clock has elapsed
-///
-/// @return true if elapsed, so it is a timeout, else false.
-bool active_diagnostic_request_t::timed_out()
-{
-	// don't use staggered start with the timeout clock
-	return timeout_clock_.elapsed(false);
-}
-
-/// @brief Returns true if a sufficient response has been received for a
-/// diagnostic request.
-///
-/// This is true when at least one response has been received and the request is
-/// configured to not wait for multiple responses. Functional broadcast requests
-/// may often wish to wait the full 100ms for modules to respond.
-bool active_diagnostic_request_t::response_received() const
-{
-	return !wait_for_multiple_responses_ &&
-				handle_->completed;
-}
-
-/// @brief Returns true if the request has timed out waiting for a response,
-/// or a sufficient number of responses has been received.
-bool active_diagnostic_request_t::request_completed()
-{
-	return response_received() || 
-		(timed_out() && diagnostic_request_sent(handle_));
-}
diff --git a/low-can-binding/diagnostic/active-diagnostic-request.hpp b/low-can-binding/diagnostic/active-diagnostic-request.hpp
deleted file mode 100644
index 247eeb1..0000000
--- a/low-can-binding/diagnostic/active-diagnostic-request.hpp
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * 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 <string>
-#include <vector>
-
-#include "uds/uds.h"
-#include "uds/uds_types.h"
-#include "../utils/timer.hpp"
-#include "../can/can-bus-dev.hpp"
-
-class active_diagnostic_request_t;
-class diagnostic_manager_t;
-
-/// @brief The signature for an optional function that can apply the neccessary
-/// formula to translate the binary payload into meaningful data.
-///
-/// @param[in] response - the received DiagnosticResponse (the data is in response.payload,
-///  a byte array). This is most often used when the byte order is signiticant, i.e. with many OBD-II PID formulas.
-/// @param[in] parsed_payload - the entire payload of the response parsed as an int.
-///
-/// @return float value after decoding.
-///
-typedef float (*DiagnosticResponseDecoder)(const DiagnosticResponse* response,
-		float parsed_payload);
-
-/// @brief: The signature for an optional function to handle a new diagnostic
-/// response.
-///
-/// @param[in] request - The original diagnostic request.
-/// @param[in] response - The response object that was just received.
-/// @param[in] parsed_payload - The payload of the response, parsed as a float.
-///
-typedef void (*DiagnosticResponseCallback)(const active_diagnostic_request_t* request,
-		const DiagnosticResponse* response, float parsed_payload);
-
-///
-/// @brief An active diagnostic request, either recurring or one-time.
-///
-/// Will host a diagnostic_message_t class members to describe an on going
-///  diagnostic request on the CAN bus. Diagnostic message will be converted to
-///  a DiagnosticRequest using ad-hoc method build_diagnostic_request from diagnostic message.
-///  Then missing member, that can not be hosted into a DiagnosticRequest struct, will be passed
-///  as argument when adding the request to (non)-recurrent vector. Argument will be used to instanciate
-///  an active_diagnostic_request_t object before sending it.
-///
-class active_diagnostic_request_t {
-private:
-	std::string bus_; ///< bus_ - The CAN bus this request should be made on, or is currently in flight-on
-	uint32_t id_; ///< id_ - The arbitration ID (aka message ID) for the request.
-	DiagnosticRequestHandle* handle_; ///< handle_ - A handle for the request to keep track of it between
-									  ///< sending the frames of the request and receiving all frames of the response.
-	std::string name_; ///< name_ - Human readable name, to be used when publishing received responses.
-					   ///< TODO: If the name is NULL, the published output will use the raw OBD-II response format.
-	static std::string prefix_; ///< prefix_ - It has to reflect the JSON object which it comes from. It makes easier sorting 
-								///< incoming CAN messages.
-	DiagnosticResponseDecoder decoder_; ///< decoder_ - An optional DiagnosticResponseDecoder to parse the payload of responses
-										///< to this request. If the decoder is NULL, the output will include the raw payload
-										///< instead of a parsed value.
-	DiagnosticResponseCallback callback_; ///< callback_ - An optional DiagnosticResponseCallback to be notified whenever a
-										  ///< response is received for this request.
-	bool recurring_; ///< bool recurring_ - If true, this is a recurring request and it will remain as active until explicitly cancelled.
-					 ///< The frequencyClock attribute controls how often a recurrin request is made.
-	bool wait_for_multiple_responses_; ///< wait_for_multiple_responses_ - False by default, when any response is received for a request
-									   ///< it will be removed from the active list. If true, the request will remain active until the timeout
-									   ///< clock expires, to allow it to receive multiple response (e.g. to a functional broadcast request).
-	bool in_flight_; ///< in_flight_ - True if the request has been sent and we are waiting for a response.
-	frequency_clock_t frequency_clock_; ///< frequency_clock_ - A frequency_clock_t object to control the send rate for a
-										///< recurring request. If the request is not reecurring, this attribute is not used.
-	frequency_clock_t timeout_clock_; ///< timeout_clock_ - A frequency_clock_t object to monitor how long it's been since
-									  ///< this request was sent.
-public:
-	bool operator==(const active_diagnostic_request_t& b);
-	active_diagnostic_request_t& operator=(const active_diagnostic_request_t& adr);
-
-	active_diagnostic_request_t();
-	active_diagnostic_request_t(active_diagnostic_request_t&&) = default;
-	active_diagnostic_request_t(const std::string& bus, DiagnosticRequest* request,
-		const std::string& name, bool wait_for_multiple_responses,
-		const DiagnosticResponseDecoder decoder,
-		const DiagnosticResponseCallback callback, float frequencyHz);
-
-	uint32_t get_id() const;
-	const std::shared_ptr<can_bus_dev_t> get_can_bus_dev() const;
-	DiagnosticRequestHandle* get_handle();
-	uint16_t get_pid() const;
-	const std::string get_name() const;
-	static std::string& get_prefix();
-	DiagnosticResponseDecoder& get_decoder();
-	DiagnosticResponseCallback& get_callback();
-	bool get_recurring() const;
-	bool get_in_flight() const;
-	frequency_clock_t& get_frequency_clock();
-	frequency_clock_t& get_timeout_clock();
-
-	void set_handle(DiagnosticShims& shims, DiagnosticRequest* request);
-	void set_in_flight(bool val);
-
-	static bool is_diagnostic_signal(const std::string& name);
-
-	bool should_send();
-
-	bool timed_out();
-	bool response_received() const;
-	bool request_completed();
-};
diff --git a/low-can-binding/diagnostic/diagnostic-manager.cpp b/low-can-binding/diagnostic/diagnostic-manager.cpp
deleted file mode 100644
index e3a78d0..0000000
--- a/low-can-binding/diagnostic/diagnostic-manager.cpp
+++ /dev/null
@@ -1,618 +0,0 @@
-/*
- * 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 <systemd/sd-event.h>
-#include <algorithm>
-
-#include "diagnostic-manager.hpp"
-
-#include "../utils/openxc-utils.hpp"
-#include "../configuration.hpp"
-
-#define MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ 10
-#define MAX_SIMULTANEOUS_DIAG_REQUESTS 50
-// There are only 8 slots of in flight diagnostic requests
-#define MAX_SIMULTANEOUS_IN_FLIGHT_REQUESTS 8
-#define TIMERFD_ACCURACY 0
-#define MICRO 1000000
-
-diagnostic_manager_t::diagnostic_manager_t()
-	: initialized_{false}
-{}
-
-/// @brief Diagnostic manager isn't initialized at launch but after
-///  CAN bus devices initialization. For the moment, it is only possible
-///  to have 1 diagnostic bus which are the first bus declared in the JSON
-///  description file. Configuration instance will return it.
-///
-/// this will initialize DiagnosticShims and cancel all active requests 
-///  if there are any.
-bool diagnostic_manager_t::initialize()
-{
-	// Mandatory to set the bus before intialize shims.
-	bus_ = configuration_t::instance().get_diagnostic_bus();
-
-	init_diagnostic_shims();
-	reset();
-
-	initialized_ = true;
-	DEBUG(binder_interface, "initialize: Diagnostic Manager initialized");
-	return initialized_;
-}
-
-/// @brief initialize shims used by UDS lib and set initialized_ to true.
-///  It is needed before used the diagnostic manager fully because shims are
-///  required by most member functions.
-void diagnostic_manager_t::init_diagnostic_shims()
-{
-	shims_ = diagnostic_init_shims(shims_logger, shims_send, NULL);
-	DEBUG(binder_interface, "init_diagnostic_shims: Shims initialized");
-}
-
-/// @brief Force cleanup all active requests.
-void diagnostic_manager_t::reset()
-{
-	DEBUG(binder_interface, "Clearing existing diagnostic requests");
-	cleanup_active_requests(true);
-}
-
-/// @brief send function use by diagnostic library. Only one bus used for now
-///  so diagnostic request is sent using the default diagnostic bus not matter of
-///  which is specified in the diagnostic message definition.
-///
-/// @param[in] arbitration_id - CAN arbitration ID to use when send message. OBD2 broadcast ID
-///  is 0x7DF by example.
-/// @param[in] data - The data payload for the message. NULL is valid if size is also 0.
-/// @param[in] size - The size of the data payload, in bytes.
-///
-/// @return true if the CAN message was sent successfully. 
-bool diagnostic_manager_t::shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size)
-{
-	std::shared_ptr<can_bus_dev_t> can_bus_dev = can_bus_t::get_can_device(configuration_t::instance().get_diagnostic_manager().bus_);
-	if(can_bus_dev != nullptr)
-		return can_bus_dev->shims_send(arbitration_id, data, size);
-	ERROR(binder_interface, "shims_send: Can not retrieve diagnostic bus: %s", configuration_t::instance().get_diagnostic_manager().bus_.c_str());
-	return false;
-}
-
-/// @brief The type signature for an optional logging function, if the user
-/// wishes to provide one. It should print, store or otherwise display the
-/// message.
-///
-/// message - A format string to log using the given parameters.
-/// ... (vargs) - the parameters for the format string.
-///
-void diagnostic_manager_t::shims_logger(const char* format, ...)
-{
-	va_list args;
-	va_start(args, format);
-
-	char buffer[256];
-	vsnprintf(buffer, 256, format, args);
-
-	DEBUG(binder_interface, "shims_logger: %s", buffer);
-}
-
-/// @brief The type signature for a... OpenXC TODO: not used yet.
-void diagnostic_manager_t::shims_timer()
-{}
-
-std::shared_ptr<can_bus_dev_t> diagnostic_manager_t::get_can_bus_dev()
-{
-	return can_bus_t::get_can_device(bus_);
-}
-
-/// @brief Return diagnostic manager shims member.
-DiagnosticShims& diagnostic_manager_t::get_shims()
-{
-	return shims_;
-}
-
-/// @brief Search for a specific active diagnostic request in the provided requests list
-/// and erase it from the vector. This is useful at unsubscription to clean up the list otherwize
-/// all received CAN messages will be passed to DiagnosticRequestHandle of all active diagnostic request
-/// contained in the vector but no event if connected to, so we will decode uneeded request.
-///
-/// @param[in] entry - a pointer of an active_diagnostic_request instance to clean up
-/// @param[in] requests_list - a vector where to make the search and cleaning.
-void diagnostic_manager_t::find_and_erase(active_diagnostic_request_t* entry, std::vector<active_diagnostic_request_t*>& requests_list)
-{
-	auto i = std::find(requests_list.begin(), requests_list.end(), entry);
-	if ( i != requests_list.end())
-		requests_list.erase(i);
-}
-
-// @brief TODO: implement cancel_request if needed... Don't know.
-void diagnostic_manager_t::cancel_request(active_diagnostic_request_t* entry)
-{
-
-	/* TODO: implement acceptance filters.
-	if(entry.arbitration_id_ == OBD2_FUNCTIONAL_BROADCAST_ID) {
-		for(uint32_t filter = OBD2_FUNCTIONAL_RESPONSE_START;
-				filter < OBD2_FUNCTIONAL_RESPONSE_START +
-					OBD2_FUNCTIONAL_RESPONSE_COUNT;
-				filter++) {
-			removeAcceptanceFilter(entry.bus_, filter,
-					CanMessageFormat::STANDARD, getCanBuses(),
-					getCanBusCount());
-		}
-	} else {
-		removeAcceptanceFilter(entry.bus_,
-				entry.arbitration_id_ +
-					DIAGNOSTIC_RESPONSE_ARBITRATION_ID_OFFSET,
-				CanMessageFormat::STANDARD, getCanBuses(), getCanBusCount());
-	}*/
-}
-
-/// @brief Cleanup a specific request if it isn't running and get complete. As it is almost
-/// impossible to get that state for a recurring request without waiting for that, you can 
-/// force the cleaning operation.
-///
-/// @param[in] entry - the request to clean
-/// @param[in] force - Force the cleaning or not ?
-void diagnostic_manager_t::cleanup_request(active_diagnostic_request_t* entry, bool force)
-{
-	if((force || (entry != nullptr && entry->get_in_flight() && entry->request_completed())))
-	{
-		entry->set_in_flight(false);
-
-		char request_string[128] = {0};
-		diagnostic_request_to_string(&entry->get_handle()->request,
-			request_string, sizeof(request_string));
-		if(force && entry->get_recurring())
-		{
-			find_and_erase(entry, recurring_requests_);
-			cancel_request(entry);
-			DEBUG(binder_interface, "cleanup_request: Cancelling completed, recurring request: %s", request_string);
-		}
-		else
-		{
-			DEBUG(binder_interface, "cleanup_request: Cancelling completed, non-recurring request: %s", request_string);
-			find_and_erase(entry, non_recurring_requests_);
-			cancel_request(entry);
-		}
-	}
-}
-
-/// @brief Clean up all requests lists, recurring and not recurring.
-///
-/// @param[in] force - Force the cleaning or not ? If true, that will do
-/// the same effect as a call to reset().
-void diagnostic_manager_t::cleanup_active_requests(bool force)
-{
-	for(auto& entry : non_recurring_requests_)
-		if (entry != nullptr)
-			cleanup_request(entry, force);
-
-	for(auto& entry : recurring_requests_)
-		if (entry != nullptr)
-			cleanup_request(entry, force);
-}
-
-/// @brief Will return the active_diagnostic_request_t pointer for theDiagnosticRequest or nullptr if
-/// not found.
-///
-/// @param[in] request - Search key, method will go through recurring list to see if it find that request
-///  holded by the DiagnosticHandle member.
-active_diagnostic_request_t* diagnostic_manager_t::find_recurring_request(const DiagnosticRequest* request)
-{
-	for (auto& entry : recurring_requests_)
-	{
-		if(entry != nullptr)
-		{
-			if(diagnostic_request_equals(&entry->get_handle()->request, request))
-			{
-				return entry;
-				break;
-			}
-		}
-	}
-	return nullptr;
-}
-
-/// @brief Add and send a new one-time diagnostic request.
-///
-/// A one-time (aka non-recurring) request can existing in parallel with a
-/// recurring request for the same PID or mode, that's not a problem.
-///
-/// For an example, see the docs for addRecurringRequest. This function is very
-/// similar but leaves out the frequencyHz parameter.
-///
-/// @param[in] request - The parameters for the request.
-/// @param[in] name - Human readable name this response, to be used when
-///      publishing received responses. TODO: If the name is NULL, the published output
-///      will use the raw OBD-II response format.
-/// @param[in] wait_for_multiple_responses - If false, When any response is received
-///      for this request it will be removed from the active list. If true, the
-///      request will remain active until the timeout clock expires, to allow it
-///      to receive multiple response. Functional broadcast requests will always
-///      waint for the timeout, regardless of this parameter.
-/// @param[in] decoder - An optional DiagnosticResponseDecoder to parse the payload of
-///      responses to this request. If the decoder is NULL, the output will
-///      include the raw payload instead of a parsed value.
-/// @param[in] callback - An optional DiagnosticResponseCallback to be notified whenever a
-///      response is received for this request.
-///
-/// @return true if the request was added successfully. Returns false if there
-/// wasn't a free active request entry, if the frequency was too high or if the
-/// CAN acceptance filters could not be configured,
-bool diagnostic_manager_t::add_request(DiagnosticRequest* request, const std::string name,
-	bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder,
-	const DiagnosticResponseCallback callback)
-{
-	cleanup_active_requests(false);
-
-	bool added = true;
-
-	if (non_recurring_requests_.size() <= MAX_SIMULTANEOUS_DIAG_REQUESTS)
-	{
-		// TODO: implement Acceptance Filter
-		//	if(updateRequiredAcceptanceFilters(bus, request)) {
-			active_diagnostic_request_t* entry = new active_diagnostic_request_t(bus_, request, name,
-					wait_for_multiple_responses, decoder, callback, 0);
-			entry->set_handle(shims_, request);
-
-			char request_string[128] = {0};
-			diagnostic_request_to_string(&entry->get_handle()->request, request_string,
-					sizeof(request_string));
-
-			find_and_erase(entry, non_recurring_requests_);
-			DEBUG(binder_interface, "Added one-time diagnostic request on bus %s: %s",
-					bus_.c_str(), request_string);
-
-			non_recurring_requests_.push_back(entry);
-	}
-	else
-	{
-		WARNING(binder_interface, "There isn't enough request entry. Vector exhausted %d/%d", (int)non_recurring_requests_.size(), MAX_SIMULTANEOUS_DIAG_REQUESTS);
-		non_recurring_requests_.resize(MAX_SIMULTANEOUS_DIAG_REQUESTS);
-		added = false;
-	}
-	return added;
-}
-
-bool diagnostic_manager_t::validate_optional_request_attributes(float frequencyHz)
-{
-	if(frequencyHz > MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ) {
-		DEBUG(binder_interface, "Requested recurring diagnostic frequency %lf is higher than maximum of %d",
-			frequencyHz, MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ);
-		return false;
-	}
-	return true;
-}
-
-/// @brief Add and send a new recurring diagnostic request.
-///
-/// At most one recurring request can be active for the same arbitration ID, mode
-/// and (if set) PID on the same bus at one time. If you try and call
-/// addRecurringRequest with the same key, it will return an error.
-///
-/// TODO: This also adds any neccessary CAN acceptance filters so we can receive the
-/// response. If the request is to the functional broadcast ID (0x7df) filters
-/// are added for all functional addresses (0x7e8 to 0x7f0).
-///
-/// Example:
-///
-///     // Creating a functional broadcast, mode 1 request for PID 2.
-///     DiagnosticRequest request = {
-///         arbitration_id: 0x7df,
-///         mode: 1,
-///         has_pid: true,
-///         pid: 2
-///     };
-///
-///     // Add a recurring request, to be sent at 1Hz, and published with the
-///     // name "my_pid_request"
-///     addRecurringRequest(&getConfiguration()->diagnosticsManager,
-///          canBus,
-///          &request,
-///          "my_pid_request",
-///          false,
-///          NULL,
-///          NULL,
-///          1);
-///
-/// @param[in] request - The parameters for the request.
-/// @param[in] name - An optional human readable name this response, to be used when
-///      publishing received responses. If the name is NULL, the published output
-///      will use the raw OBD-II response format.
-/// @param[in] wait_for_multiple_responses - If false, When any response is received
-///      for this request it will be removed from the active list. If true, the
-///      request will remain active until the timeout clock expires, to allow it
-///      to receive multiple response. Functional broadcast requests will always
-///      waint for the timeout, regardless of this parameter.
-/// @param[in] decoder - An optional DiagnosticResponseDecoder to parse the payload of
-///      responses to this request. If the decoder is NULL, the output will
-///      include the raw payload instead of a parsed value.
-/// @param[in] callback - An optional DiagnosticResponseCallback to be notified whenever a
-///      response is received for this request.
-/// @param[in] frequencyHz - The frequency (in Hz) to send the request. A frequency above
-///      MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ is not allowed, and will make this
-///      function return false.
-///
-/// @return true if the request was added successfully. Returns false if there
-/// was too much already running requests, if the frequency was too high TODO:or if the
-/// CAN acceptance filters could not be configured,
-///
-bool diagnostic_manager_t::add_recurring_request(DiagnosticRequest* request, const char* name,
-		bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder,
-		const DiagnosticResponseCallback callback, float frequencyHz)
-{
-	if(!validate_optional_request_attributes(frequencyHz))
-		return false;
-
-	cleanup_active_requests(false);
-
-	bool added = true;
-	if(find_recurring_request(request) == nullptr)
-	{
-		if(recurring_requests_.size() <= MAX_SIMULTANEOUS_DIAG_REQUESTS)
-		{
-			sd_event_source *source;
-			// TODO: implement Acceptance Filter
-			//if(updateRequiredAcceptanceFilters(bus, request)) {
-			active_diagnostic_request_t* entry = new active_diagnostic_request_t(bus_, request, name,
-					wait_for_multiple_responses, decoder, callback, frequencyHz);
-			entry->set_handle(shims_, request);
-
-			//start_diagnostic_request(&shims_, entry->get_handle());
-			//char request_string[128] = {0};
-			//diagnostic_request_to_string(&entry->get_handle()->request, request_string,
-			//		sizeof(request_string));
-
-			uint64_t usec;
-			sd_event_now(afb_daemon_get_event_loop(binder_interface->daemon), CLOCK_BOOTTIME, &usec);
-			if(recurring_requests_.size() > 0)
-			{
-				DEBUG(binder_interface, "add_recurring_request: Added 100ms to usec to stagger sending requests");
-				usec += 100000;
-			}
-
-			DEBUG(binder_interface, "add_recurring_request: Added recurring diagnostic request (freq: %f) on bus %s at %ld. Event loop state: %d",
-					frequencyHz,
-					bus_.c_str(),
-					usec,
-					sd_event_get_state(afb_daemon_get_event_loop(binder_interface->daemon)));
-
-			if(sd_event_add_time(afb_daemon_get_event_loop(binder_interface->daemon), &source,
-					CLOCK_BOOTTIME, usec, TIMERFD_ACCURACY, send_request, request) < 0)
-			{
-				ERROR(binder_interface, "add_recurring_request: Request fails to be schedule through event loop");
-				added = false;
-			}
-			recurring_requests_.push_back(entry);
-		}
-		else
-		{
-			WARNING(binder_interface, "add_recurring_request: There isn't enough request entry. Vector exhausted %d/%d", (int)recurring_requests_.size(), MAX_SIMULTANEOUS_DIAG_REQUESTS);
-			recurring_requests_.resize(MAX_SIMULTANEOUS_DIAG_REQUESTS);
-			added = false;
-		}
-	}
-	else
-	{
-		DEBUG(binder_interface, "add_recurring_request: Can't add request, one already exists with same key");
-		added = false;
-	}
-	return added;
-}
-
-/// @brief Returns true if there are two active requests running for the same arbitration ID.
-bool diagnostic_manager_t::conflicting(active_diagnostic_request_t* request, active_diagnostic_request_t* candidate) const
-{
-	return (candidate->get_in_flight() && candidate != request &&
-			candidate->get_can_bus_dev() == request->get_can_bus_dev() &&
-			candidate->get_id() == request->get_id());
-}
-
-
-/// @brief Returns true if there are no other active requests to the same arbitration ID
-/// and if there aren't more than 8 requests in flight at the same time.
-bool diagnostic_manager_t::clear_to_send(active_diagnostic_request_t* request) const
-{
-	int total_in_flight = 0;
-	for ( auto entry : non_recurring_requests_)
-	{
-		if(conflicting(request, entry))
-			return false;
-		if(entry->get_in_flight())
-			total_in_flight++;
-	}
-
-	for ( auto entry : recurring_requests_)
-	{
-		if(conflicting(request, entry))
-			return false;
-		if(entry->get_in_flight())
-			total_in_flight++;
-	}
-
-	if(total_in_flight > MAX_SIMULTANEOUS_IN_FLIGHT_REQUESTS)
-		return false;
-	return true;
-}
-
-int diagnostic_manager_t::reschedule_request(sd_event_source *s, uint64_t usec, active_diagnostic_request_t* adr)
-{
-	usec = usec + (uint64_t)(adr->get_frequency_clock().frequency_to_period());
-	DEBUG(binder_interface, "send_request: Event loop state: %d. usec: %ld", sd_event_get_state(afb_daemon_get_event_loop(binder_interface->daemon)), usec);
-	if(sd_event_source_set_time(s, usec) >= 0)
-		if(sd_event_source_set_enabled(s, SD_EVENT_ON) >= 0)
-			return 0;
-	sd_event_source_unref(s);
-	return -1;
-}
-
-/// @brief Systemd timer event callback use to send CAN messages at regular interval. Depending
-/// on the diagnostic message frequency.
-///
-/// This should be called from systemd binder event loop and the event is created on add_recurring_request
-///
-/// @param[in] s - Systemd event source pointer used to reschedule the new iteration.
-/// @param[in] usec - previous call timestamp in microseconds.
-/// @param[in] userdata - the DiagnosticRequest struct, use to retrieve the active request from the list.
-///
-/// @return positive integer if sent and rescheduled or negative value if something wrong. If an error occurs
-/// event will be disabled.
-int diagnostic_manager_t::send_request(sd_event_source *s, uint64_t usec, void *userdata)
-{
-	diagnostic_manager_t& dm = configuration_t::instance().get_diagnostic_manager();
-	DiagnosticRequest* request = (DiagnosticRequest*)userdata;
-	active_diagnostic_request_t* adr = dm.find_recurring_request(request);
-
-	dm.cleanup_active_requests(false);
-	if(adr != nullptr && adr->get_can_bus_dev() == dm.get_can_bus_dev() && adr->should_send() &&
-		dm.clear_to_send(adr))
-	{
-		adr->get_frequency_clock().tick();
-		start_diagnostic_request(&dm.shims_, adr->get_handle());
-		if(adr->get_handle()->completed && !adr->get_handle()->success)
-		{
-				ERROR(binder_interface, "send_request: Fatal error sending diagnostic request");
-				sd_event_source_unref(s);
-				return -1;
-		}
-
-		adr->get_timeout_clock().tick();
-		adr->set_in_flight(true);
-	}
-
-	if(adr != nullptr && adr->get_recurring())
-	{
-		return dm.reschedule_request(s, usec, adr);
-	}
-
-	sd_event_source_unref(s);
-	NOTICE(binder_interface, "send_request: Request doesn't exist anymore. Canceling.'");
-	return -2;
-}
-
-/// @brief Will decode the diagnostic response and build the final openxc_VehicleMessage to return.
-///
-/// @param[in] adr - A pointer to an active diagnostic request holding a valid diagnostic handle
-/// @param[in] response - The response to decode from which the Vehicle message will be built and returned
-///
-/// @return A filled openxc_VehicleMessage or a zeroed struct if there is an error.
-openxc_VehicleMessage diagnostic_manager_t::relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response)
-{
-	openxc_VehicleMessage message = build_VehicleMessage();
-	float value = (float)diagnostic_payload_to_integer(&response);
-	if(adr->get_decoder() != nullptr)
-	{
-		value = adr->get_decoder()(&response, value);
-	}
-
-	if((response.success && strnlen(adr->get_name().c_str(), adr->get_name().size())) > 0)
-	{
-		// If name, include 'value' instead of payload, and leave of response
-		// details.
-		message = build_VehicleMessage(build_SimpleMessage(adr->get_name(), build_DynamicField(value)));
-	}
-	else
-	{
-		// If no name, send full details of response but still include 'value'
-		// instead of 'payload' if they provided a decoder. The one case you
-		// can't get is the full detailed response with 'value'. We could add
-		// another parameter for that but it's onerous to carry that around.
-		message = build_VehicleMessage(adr, response, value);
-	}
-
-	// If not success but completed then the pid isn't supported
-	if(!response.success)
-	{
-		std::vector<diagnostic_message_t*> found_signals;
-		configuration_t::instance().find_diagnostic_messages( build_DynamicField(adr->get_name()), found_signals );
-		found_signals.front()->set_supported(false);
-		cleanup_request(adr, true);
-		NOTICE(binder_interface, "relay_diagnostic_response: PID not supported or ill formed. Please unsubscribe from it. Error code : %d", response.negative_response_code);
-		message = build_VehicleMessage(build_SimpleMessage(adr->get_name(), build_DynamicField("This PID isn't supported by your vehicle.")));
-	}
-
-	if(adr->get_callback() != nullptr)
-	{
-		adr->get_callback()(adr, &response, value);
-	}
-
-	return message;
-}
-
-/// @brief Will take the CAN message and pass it to the receive functions that will process
-/// diagnostic handle for each active diagnostic request then depending on the result we will 
-/// return pass the diagnostic response to decode it.
-///
-/// @param[in] entry - A pointer to an active diagnostic request holding a valid diagnostic handle
-/// @param[in] cm - A raw CAN message.
-///
-/// @return A pointer to a filled openxc_VehicleMessage or a nullptr if nothing has been found.
-openxc_VehicleMessage diagnostic_manager_t::relay_diagnostic_handle(active_diagnostic_request_t* entry, const can_message_t& cm)
-{
-	DiagnosticResponse response = diagnostic_receive_can_frame(&shims_, entry->get_handle(), cm.get_id(), cm.get_data(), cm.get_length());
-	if(response.completed && entry->get_handle()->completed)
-	{
-		if(entry->get_handle()->success)
-			return relay_diagnostic_response(entry, response);
-	}
-	else if(!response.completed && response.multi_frame)
-	{
-		// Reset the timeout clock while completing the multi-frame receive
-		entry->get_timeout_clock().tick();
-	}
-
-	return build_VehicleMessage();
-}
-
-/// @brief Find the active diagnostic request with the correct DiagnosticRequestHandle
-/// member that will understand the CAN message using diagnostic_receive_can_frame function
-/// from UDS-C library. Then decode it with an ad-hoc method.
-///
-/// @param[in] cm - Raw CAN message received
-///
-/// @return VehicleMessage with decoded value.
-openxc_VehicleMessage diagnostic_manager_t::find_and_decode_adr(const can_message_t& cm)
-{
-	openxc_VehicleMessage vehicle_message = build_VehicleMessage();
-
-	for ( auto entry : non_recurring_requests_)
-	{
-		vehicle_message = relay_diagnostic_handle(entry, cm);
-		if (is_valid(vehicle_message))
-			return vehicle_message;
-	}
-
-	for ( auto entry : recurring_requests_)
-	{
-		vehicle_message = relay_diagnostic_handle(entry, cm);
-		if (is_valid(vehicle_message))
-			return vehicle_message;
-	}
-
-	return vehicle_message;
-}
-
-/// @brief Tell if the CAN message received is a diagnostic response.
-/// Request broadcast ID use 0x7DF and assigned ID goes from 0x7E0 to Ox7E7. That allows up to 8 ECU to respond 
-/// at the same time. The response is the assigned ID + 0x8, so response ID can goes from 0x7E8 to 0x7EF.
-///
-/// @param[in] cm - CAN message received from the socket.
-///
-/// @return True if the active diagnostic request match the response.
-bool diagnostic_manager_t::is_diagnostic_response(const can_message_t& cm)
-{
-	if (cm.get_id() >= 0x7e8 && cm.get_id() <= 0x7ef)
-			return true;
-	return false;
-}
diff --git a/low-can-binding/diagnostic/diagnostic-manager.hpp b/low-can-binding/diagnostic/diagnostic-manager.hpp
deleted file mode 100644
index 3edb2b1..0000000
--- a/low-can-binding/diagnostic/diagnostic-manager.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * 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 <systemd/sd-event.h>
-#include <map>
-#include <vector>
-
-#include "uds/uds.h"
-#include "openxc.pb.h"
-#include "../can/can-bus.hpp"
-#include "active-diagnostic-request.hpp"
-
-///  Each CAN bus needs its own set of shim functions, so this should
-/// match the maximum CAN controller count.
-///
-#define MAX_SHIM_COUNT can_bus_t.get_can_devices().size()
-#define DIAGNOSTIC_RESPONSE_ARBITRATION_ID_OFFSET 0x8
-
-class active_diagnostic_request_t;
-
-///
-/// @brief The core structure for running the diagnostics module by the binding.
-///
-/// This stores details about the active requests and shims required to connect
-/// the diagnostics library to the CAN device.
-///
-class diagnostic_manager_t {
-protected:
-	static bool shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size);
-	static void shims_logger(const char* m, ...);
-	static void shims_timer();
-
-private:
-	DiagnosticShims shims_; /*!< shims_ - Shim functions for each CAN bus that plug the diagnostics
-							 * library (uds-c) into the VI's CAN peripheral.*/
-	std::string bus_; /*!< bus_ - A pointer to the CAN bus that should be used for all standard OBD-II requests, if the bus is not
-						* explicitly spcified in the request. Default to the first bus CAN at initialization.*/
-	std::vector<active_diagnostic_request_t*> recurring_requests_; /*!< recurringRequests - A list of active recurring diagnostic requests.*/
-	std::vector<active_diagnostic_request_t*> non_recurring_requests_; /*!< nonrecurringRequests - A list of active one-time diagnostic requests. When a
-																	   * response is received for a non-recurring request or it times out, it is removed*/
-	bool initialized_; /*!< * initialized - True if the DiagnosticsManager has been initialized with shims. It will interface with the uds-c lib*/
-
-	void init_diagnostic_shims();
-	void reset();
-public:
-	diagnostic_manager_t();
-
-	bool initialize();
-
-	std::shared_ptr<can_bus_dev_t> get_can_bus_dev();
-	DiagnosticShims& get_shims();
-
-	void find_and_erase(active_diagnostic_request_t* entry, std::vector<active_diagnostic_request_t*>& requests_list);
-	void cancel_request(active_diagnostic_request_t* entry);
-	void cleanup_request(active_diagnostic_request_t* entry, bool force);
-	void cleanup_active_requests(bool force);
-	active_diagnostic_request_t* find_recurring_request(const DiagnosticRequest* request);
-
-	void checkSupportedPids(const active_diagnostic_request_t& request,
-		const DiagnosticResponse& response, float parsedPayload);
-
-	// Subscription parts
-	bool add_request(DiagnosticRequest* request, const std::string name,
-		bool waitForMultipleResponses, const DiagnosticResponseDecoder decoder,
-		const DiagnosticResponseCallback callback);
-	bool validate_optional_request_attributes(float frequencyHz);
-	bool add_recurring_request(DiagnosticRequest* request, const char* name,
-		bool waitForMultipleResponses, const DiagnosticResponseDecoder decoder,
-		const DiagnosticResponseCallback callback, float frequencyHz);
-
-	// Sendig requests part
-	bool conflicting(active_diagnostic_request_t* request, active_diagnostic_request_t* candidate) const;
-	bool clear_to_send(active_diagnostic_request_t* request) const;
-	int reschedule_request(sd_event_source *s, uint64_t usec, active_diagnostic_request_t* adr);
-	static int send_request(sd_event_source *s, uint64_t usec, void *userdata);
-
-	// Decoding part
-	openxc_VehicleMessage relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response);
-	openxc_VehicleMessage relay_diagnostic_handle(active_diagnostic_request_t* entry, const can_message_t& cm);
-	openxc_VehicleMessage find_and_decode_adr(const can_message_t& cm);
-	bool is_diagnostic_response(const can_message_t& cm);
-
-};
diff --git a/low-can-binding/diagnostic/diagnostic-message.cpp b/low-can-binding/diagnostic/diagnostic-message.cpp
deleted file mode 100644
index 6f61557..0000000
--- a/low-can-binding/diagnostic/diagnostic-message.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * 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 <map>
-
-#include "diagnostic-message.hpp"
-
-#include "../configuration.hpp"
-#include "../utils/signals.hpp"
-
-const char *UNIT_NAMES[10] = {
-	"POURCENT",
-	"DEGREES_CELSIUS",
-	"KPA",
-	"RPM",
-	"GRAMS_SEC",
-	"SECONDS",
-	"KM",
-	"KM_H",
-	"PA",
-	"NM"
-};
-
-diagnostic_message_t::diagnostic_message_t(uint8_t pid, const std::string generic_name, const int min,
-	const int max, enum UNIT unit, float frequency,	DiagnosticResponseDecoder decoder,
-	DiagnosticResponseCallback callback, bool supported)
-	: pid_{pid}, generic_name_{generic_name}, min_{min}, max_{max}, unit_{unit},
-	frequency_{frequency}, decoder_{decoder}, callback_{callback}, supported_{supported}
-{}
-
-uint32_t diagnostic_message_t::get_pid()
-{
-	return (uint32_t)pid_;
-}
-
-const std::string& diagnostic_message_t::get_generic_name() const
-{
-	return generic_name_;
-}
-
-const std::string diagnostic_message_t::get_name() const
-{
-	return active_diagnostic_request_t::get_prefix() + "." + generic_name_;
-}
-
-float diagnostic_message_t::get_frequency() const
-{
-	return frequency_;
-}
-
-DiagnosticResponseDecoder diagnostic_message_t::get_decoder() const
-{
-	return decoder_;
-}
-DiagnosticResponseCallback diagnostic_message_t::get_callback() const
-{
-	return callback_;
-}
-
-bool diagnostic_message_t::get_supported() const
-{
-	return supported_;
-}
-
-void diagnostic_message_t::set_supported(bool value)
-{
-	supported_ = value;
-}
-
-///
-/// @brief Build a DiagnosticRequest struct to be passed
-///  to diagnostic manager instance.
-///
-const DiagnosticRequest diagnostic_message_t::build_diagnostic_request()
-{
-	return {/*arbitration_id: */OBD2_FUNCTIONAL_BROADCAST_ID,
-			/*mode: */0x1,
-			/*has_pid: */true,
-			/*pid: */pid_,
-			/*pid_length: */0,
-			/*payload[]: */{0},
-			/*payload_length: */0,
-			/*no_frame_padding: */false,
-			/*DiagnosticRequestType: */DiagnosticRequestType::DIAGNOSTIC_REQUEST_TYPE_PID };
-}
-
-///
-/// @brief Check if a request is an OBD-II PID request.
-///
-/// @return true if the request is a mode 1 request and it has a 1 byte PID.
-///
-bool diagnostic_message_t::is_obd2_request(const DiagnosticRequest* request)
-{
-	return request->mode == 0x1 && request->has_pid && request->pid < 0xff;
-}
diff --git a/low-can-binding/diagnostic/diagnostic-message.hpp b/low-can-binding/diagnostic/diagnostic-message.hpp
deleted file mode 100644
index 064904d..0000000
--- a/low-can-binding/diagnostic/diagnostic-message.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * 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 "uds/uds.h"
-#include "../can/can-message.hpp"
-#include "active-diagnostic-request.hpp"
-
-enum UNIT {
-	POURCENT,
-	DEGREES_CELSIUS,
-	KPA,
-	RPM,
-	GRAMS_SEC,
-	SECONDS,
-	KM,
-	KM_H,
-	PA,
-	NM,
-	INVALID
-};
-
-///
-/// @brief - A representation of an OBD-II PID.
-///
-class diagnostic_message_t {
-	private:
-		uint8_t pid_; /*!< pid_ - The 1 byte PID.*/
-		std::string generic_name_; /*!< generic_name_ - A human readable name to use for this PID when published.*/
-		int min_; /*!< min_ - Minimum value that can take this pid */
-		int max_; /*!< max_ - Maximum value that can take this pid */
-		enum UNIT unit_; /*!< unit_ : Which unit system is used by that pid. See enum UNIT above.*/
-		float frequency_; /*!< frequency_ - The frequency to request this PID if supported by the vehicle when automatic, recurring OBD-II requests are enabled.*/
-		DiagnosticResponseDecoder decoder_; /*!< decoder_ - An optional DiagnosticResponseDecoder to parse the payload of responses
-											 * to this request. If the decoder is NULL, the output will include the raw payload
-											 * instead of a parsed value.*/
-		DiagnosticResponseCallback callback_; /*!< callback_ - An optional DiagnosticResponseCallback to be notified whenever a
-											   * response is received for this request.*/
-
-		bool supported_; /*!< supported_ - boolean indicating whether this pid is supported by the vehicle or not.*/
-
-	public:
-		const char* generic_name = generic_name_.c_str();
-		diagnostic_message_t(uint8_t pid, const std::string generic_name, const int min, const int max, enum UNIT unit, float frequency,
-											DiagnosticResponseDecoder decoder, DiagnosticResponseCallback callback, bool supported);
-
-		uint32_t get_pid();
-		const std::string& get_generic_name() const;
-		const std::string get_name() const;
-		float get_frequency() const;
-		DiagnosticResponseDecoder get_decoder() const;
-		DiagnosticResponseCallback get_callback() const;
-		bool get_supported() const;
-
-		void set_supported(bool value);
-
-		const DiagnosticRequest build_diagnostic_request();
-
-		bool is_obd2_response(const can_message_t& can_message);
-		bool is_obd2_request(const DiagnosticRequest *request);
-};
diff --git a/low-can-binding/low-can-binding.cpp b/low-can-binding/low-can-binding.cpp
deleted file mode 100644
index 07b3f1e..0000000
--- a/low-can-binding/low-can-binding.cpp
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
- * 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 "low-can-binding.hpp"
-
-#include <map>
-#include <queue>
-#include <mutex>
-#include <vector>
-#include <thread>
-#include <time.h>
-#include <linux/can.h>
-#include <json-c/json.h>
-
-#include "openxc.pb.h"
-#include "configuration.hpp"
-#include "can/can-bus.hpp"
-#include "can/can-signals.hpp"
-#include "can/can-message.hpp"
-#include "utils/timer.hpp"
-#include "utils/signals.hpp"
-#include "diagnostic/diagnostic-message.hpp"
-#include "utils/openxc-utils.hpp"
-
-extern "C"
-{
-	#include <afb/afb-service-itf.h>
-};
-
-// Interface between the daemon and the binding
-const struct afb_binding_interface *binder_interface;
-
-void on_no_clients(std::string message)
-{
-	DiagnosticRequest* diag_req = configuration_t::instance().get_request_from_diagnostic_message(message);
-	if(diag_req != nullptr)
-	{
-		active_diagnostic_request_t* adr = configuration_t::instance().get_diagnostic_manager().find_recurring_request(diag_req);
-		if( adr != nullptr)
-			configuration_t::instance().get_diagnostic_manager().cleanup_request(adr, true);
-	}
-}
-
-///******************************************************************************
-///
-///		Subscription and unsubscription
-///
-///*******************************************************************************/
-
-static int make_subscription_unsubscription(struct afb_req request, const std::string& sig_name, std::map<std::string, struct afb_event>& s, bool subscribe)
-{
-	/* Make the subscription or unsubscription to the event */
-	if (((subscribe ? afb_req_subscribe : afb_req_unsubscribe)(request, s[sig_name])) < 0)
-	{
-		ERROR(binder_interface, "make_subscription_unsubscription: Operation goes wrong for signal: %s", sig_name.c_str());
-		return 0;
-	}
-	return 1;
-}
-
-static int create_event_handle(const std::string& sig_name, std::map<std::string, struct afb_event>& s)
-{
-	s[sig_name] = afb_daemon_make_event(binder_interface->daemon, sig_name.c_str());
-	if (!afb_event_is_valid(s[sig_name]))
-	{
-		ERROR(binder_interface, "create_event_handle: Can't create an event for %s, something goes wrong.", sig_name.c_str());
-		return 0;
-	}
-	return 1;
-}
-
-static int subscribe_unsubscribe_signal(struct afb_req request, bool subscribe, const std::string& sig)
-{
-	int ret;
-
-	std::lock_guard<std::mutex> subscribed_signals_lock(get_subscribed_signals_mutex());
-	std::map<std::string, struct afb_event>& s = get_subscribed_signals();
-	if (s.find(sig) != s.end())
-	{
-		if (!afb_event_is_valid(s[sig]) && !subscribe)
-		{
-			NOTICE(binder_interface, "subscribe_unsubscribe_signal: Event isn't valid, it can't be unsubscribed.");
-			ret = -1;
-		}
-		/*else
-		{
-			// Event it isn't valid annymore, recreate it
-			ret = create_event_handle(sig, s);
-		}*/
-	}
-	else
-	{
-		/* Event doesn't exist , so let's create it */
-		struct afb_event empty_event = {nullptr, nullptr};
-		subscribed_signals[sig] = empty_event;
-		ret = create_event_handle(sig, s);
-	}
-
-	/* Check whether or not the event handler has been correctly created and
-	 * make the subscription/unsubscription operation is so.
-	 */
-	if (ret <= 0)
-		return ret;
-	return make_subscription_unsubscription(request, sig, s, subscribe);
-}
-
-///
-/// @fn static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, const std::vector<can_signal_t>& signals)
-/// @brief subscribe to all signals in the vector signals
-///
-/// @param[in] afb_req request : contain original request use to subscribe or unsubscribe
-/// @param[in] subscribe boolean value used to chose between a subscription operation or an unsubscription
-/// @param[in] can_signal_t  vector with can_signal_t to subscribe
-///
-/// @return Number of correctly subscribed signal
-///
-static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, const std::vector<std::string>& signals)
-{
-	int rets = 0;
-
-	//TODO: Implement way to dynamically call the right function no matter
-	// how much signals types we have.
-
-	for(const std::string& sig : signals)
-	{
-		int ret;
-		if (active_diagnostic_request_t::is_diagnostic_signal(sig))
-		{
-			diagnostic_message_t* diag_msg = configuration_t::instance().get_diagnostic_message(sig);
-			DiagnosticRequest* diag_req = configuration_t::instance().get_request_from_diagnostic_message(diag_msg);
-
-			// If the requested diagnostic message isn't supported by the car then unssubcribe.
-			// no matter what we want, worse case will be a fail unsubscription but at least we don't
-			// poll a PID for nothing.
-			if(diag_msg->get_supported() && subscribe)
-			{
-					float frequency = diag_msg->get_frequency();
-					subscribe = configuration_t::instance().get_diagnostic_manager().add_recurring_request(
-						diag_req, sig.c_str(), false, diag_msg->get_decoder(), diag_msg->get_callback(), (float)frequency);
-						//TODO: Adding callback requesting ignition status:	diag_req, sig.c_str(), false, diagnostic_message_t::decode_obd2_response, diagnostic_message_t::check_ignition_status, frequency);
-			}
-			else
-			{
-				configuration_t::instance().get_diagnostic_manager().cleanup_request(
-					configuration_t::instance().get_diagnostic_manager().find_recurring_request(diag_req), true);
-				WARNING(binder_interface, "Signal: %s isn't supported. Canceling operation.", sig.c_str());
-				return -1;
-			}
-		}
-
-		ret = subscribe_unsubscribe_signal(request, subscribe, sig);
-		if(ret <= 0)
-			return ret;
-		rets++;
-
-		DEBUG(binder_interface, "Signal: %s subscribed", sig.c_str());
-	}
-	return rets;
-}
-
-static int subscribe_unsubscribe_name(struct afb_req request, bool subscribe, const char *name)
-{
-	std::vector<std::string> signals;
-	int ret = 0;
-
-	openxc_DynamicField search_key = build_DynamicField(std::string(name));
-	signals = find_signals(search_key);
-	if (signals.empty())
-		ret = 0;
-
-	ret = subscribe_unsubscribe_signals(request, subscribe, signals);
-	NOTICE(binder_interface, "Subscribed/unsubscribe correctly to %d/%d signal(s).", ret, (int)signals.size());
-
-	return ret;
-}
-
-static void subscribe_unsubscribe(struct afb_req request, bool subscribe)
-{
-	int ok, i, n;
-	struct json_object *args, *a, *x;
-
-	/* makes the subscription/unsubscription */
-	args = afb_req_json(request);
-	if (args == NULL || !json_object_object_get_ex(args, "event", &a)) {
-		ok = subscribe_unsubscribe_name(request, subscribe, "*");
-	} else if (json_object_get_type(a) != json_type_array) {
-		ok = subscribe_unsubscribe_name(request, subscribe, json_object_get_string(a));
-	} else {
-		n = json_object_array_length(a);
-		ok = 0;
-		for (i = 0 ; i < n ; i++) {
-			x = json_object_array_get_idx(a, i);
-			if (subscribe_unsubscribe_name(request, subscribe, json_object_get_string(x)))
-				ok++;
-		}
-		ok = (ok == n);
-	}
-
-	/* send the report */
-	if (ok)
-		afb_req_success(request, NULL, NULL);
-	else
-		afb_req_fail(request, "error", NULL);
-}
-
-extern "C"
-{
-	static void subscribe(struct afb_req request)
-	{
-		subscribe_unsubscribe(request, true);
-	}
-
-	static void unsubscribe(struct afb_req request)
-	{
-		subscribe_unsubscribe(request, false);
-	}
-
-	static const struct afb_verb_desc_v1 verbs[]=
-	{
-		{ .name= "subscribe",	.session= AFB_SESSION_NONE, .callback= subscribe,	.info= "subscribe to notification of CAN bus messages." },
-		{ .name= "unsubscribe",	.session= AFB_SESSION_NONE, .callback= unsubscribe,	.info= "unsubscribe a previous subscription." }
-	};
-
-	static const struct afb_binding binding_desc {
-		AFB_BINDING_VERSION_1,
-		{
-			"Low level CAN bus service",
-			"low-can",
-			verbs
-		}
-	};
-
-	const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf)
-	{
-		binder_interface = itf;
-
-		return &binding_desc;
-	}
-
-	/// @brief Initialize the binding.
-	///
-	/// @param[in] service Structure which represent the Application Framework Binder.
-	///
-	/// @return Exit code, zero if success.
-	int afbBindingV1ServiceInit(struct afb_service service)
-	{
-		can_bus_t& can_bus_manager = configuration_t::instance().get_can_bus_manager();
-
-		/// Initialize CAN socket
-		if(can_bus_manager.init_can_dev() == 0)
-		{
-			can_bus_manager.start_threads();
-
-			/// Initialize Diagnostic manager that will handle obd2 requests.
-			/// We pass by default the first CAN bus device to its Initialization.
-			/// TODO: be able to choose the CAN bus device that will be use as Diagnostic bus.
-			if(configuration_t::instance().get_diagnostic_manager().initialize())
-				return 0;
-		}
-
-		ERROR(binder_interface, "There was something wrong with CAN device Initialization. Check your config file maybe");
-		return 1;
-	}
-};
diff --git a/low-can-binding/low-can-binding.hpp b/low-can-binding/low-can-binding.hpp
deleted file mode 100644
index ed5741d..0000000
--- a/low-can-binding/low-can-binding.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * 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 <cstddef>
-#include <string>
-
-extern "C"
-{
-	#include <afb/afb-binding.h>
-};
-
-extern "C" struct afb_binding_interface;
-
-extern const struct afb_binding_interface *binder_interface;
-
-void on_no_clients(std::string message);
\ No newline at end of file
diff --git a/low-can-binding/packaging/wgt/config.xml b/low-can-binding/packaging/wgt/config.xml
deleted file mode 100644
index d735ce2..0000000
--- a/low-can-binding/packaging/wgt/config.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<widget xmlns="http://www.w3.org/ns/widgets" id="@PROJECT_NAME@" version="@PROJECT_VERSION@">
-  <name>@PROJECT_NAME@</name>
-  <icon src="icon.png"/>
-  <content src="libs" type="application/vnd.agl.service"/>
-  <description>This is a demo application used to control and dialog with HVAC system</description>
-  <author>Romain Forlot &lt;romain.forlot@iot.bzh&gt;</author>
-  <license>APL 2.0</license>
-</widget>
-
-
diff --git a/low-can-binding/packaging/wgt/etc/can_buses.json b/low-can-binding/packaging/wgt/etc/can_buses.json
deleted file mode 100644
index c4292df..0000000
--- a/low-can-binding/packaging/wgt/etc/can_buses.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-	"canbus":  "can0"
-}
diff --git a/low-can-binding/packaging/wgt/icon.png b/low-can-binding/packaging/wgt/icon.png
deleted file mode 100644
index 9bd6a6e..0000000
--- a/low-can-binding/packaging/wgt/icon.png
+++ /dev/null
diff --git a/low-can-binding/utils/config-parser.cpp b/low-can-binding/utils/config-parser.cpp
deleted file mode 100644
index e73b0f9..0000000
--- a/low-can-binding/utils/config-parser.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * 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/low-can-binding/utils/config-parser.hpp b/low-can-binding/utils/config-parser.hpp
deleted file mode 100644
index e6bd9d2..0000000
--- a/low-can-binding/utils/config-parser.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * 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/low-can-binding/utils/openxc-utils.cpp b/low-can-binding/utils/openxc-utils.cpp
deleted file mode 100644
index 52b49d2..0000000
--- a/low-can-binding/utils/openxc-utils.cpp
+++ /dev/null
@@ -1,282 +0,0 @@
-/*
- * 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/low-can-binding/utils/openxc-utils.hpp b/low-can-binding/utils/openxc-utils.hpp
deleted file mode 100644
index d36b359..0000000
--- a/low-can-binding/utils/openxc-utils.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * 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/low-can-binding/utils/signals.cpp b/low-can-binding/utils/signals.cpp
deleted file mode 100644
index 2e14a98..0000000
--- a/low-can-binding/utils/signals.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * 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/low-can-binding/utils/signals.hpp b/low-can-binding/utils/signals.hpp
deleted file mode 100644
index e941756..0000000
--- a/low-can-binding/utils/signals.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * 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/low-can-binding/utils/socket.cpp b/low-can-binding/utils/socket.cpp
deleted file mode 100644
index e75e27f..0000000
--- a/low-can-binding/utils/socket.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * 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/low-can-binding/utils/socket.hpp b/low-can-binding/utils/socket.hpp
deleted file mode 100644
index b42eee6..0000000
--- a/low-can-binding/utils/socket.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#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/low-can-binding/utils/timer.cpp b/low-can-binding/utils/timer.cpp
deleted file mode 100644
index a35a3e9..0000000
--- a/low-can-binding/utils/timer.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * 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/low-can-binding/utils/timer.hpp b/low-can-binding/utils/timer.hpp
deleted file mode 100644
index f565904..0000000
--- a/low-can-binding/utils/timer.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * 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