Introducing diagnostic manager class.

It will hold communication through uds-c lib allowing
to communication with diagnostic protocol obd2. It is
attached to can_bus_dev_t class 'cause it must regularly
send CAN message through it.

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

6 files changed, 133 insertions, 21 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index a1a32532..b01ee07f 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -85,6 +85,7 @@ message(STATUS "Creation of ${PROJECT_NAME} binding for AFB-DAEMON")
 ###########################################################################
 add_library(${PROJECT_NAME} MODULE ${PROJECT_NAME}.cpp 
 	can/can-bus.cpp can/can-message.cpp can/can-signals.cpp can/can-decoder.cpp
+	obd2/obd2-signals.cpp obd2/diagnostic-manager.cpp
 	utils/signals.cpp utils/openxc-utils.cpp utils/timer.cpp)
 target_link_libraries(${PROJECT_NAME} ${EXTRAS_LIBRARIES} bitfield isotp uds openxc pthread)
 
diff --git a/src/can/can-bus.cpp b/src/can/can-bus.cpp
index 851f62a5..034e0ac9 100644
--- a/src/can/can-bus.cpp
+++ b/src/can/can-bus.cpp
@@ -31,6 +31,7 @@
 
 #include "can/can-decoder.hpp"
 #include "utils/openxc-utils.hpp"
+#include "obd2/diagnostic-manager.hpp"
 
 extern "C"
 {
@@ -363,10 +364,9 @@ std::map<std::string, std::shared_ptr<can_bus_dev_t>> can_bus_t::get_can_devices
 *
 * @param const string representing the device name into the linux /dev tree
 */
-can_bus_dev_t::can_bus_dev_t(const std::string &dev_name)
-	: device_name_{dev_name}, can_socket_{-1}
-{
-}
+can_bus_dev_t::can_bus_dev_t(const std::string& dev_name)
+	: device_name_{dev_name}, can_socket_{-1}, diagnostic_manager_{diagnostic_manager_t(*this)}
+{}
 
 /**
 * @brief Open the can socket and returning it 
diff --git a/src/can/can-bus.hpp b/src/can/can-bus.hpp
index 0fa13b22..3f85b4eb 100644
--- a/src/can/can-bus.hpp
+++ b/src/can/can-bus.hpp
@@ -27,6 +27,8 @@
 #include "utils/timer.hpp"
 #include "can/can-signals.hpp"
 #include "can/can-message.hpp"
+#include "obd2/diagnostic-manager.hpp"
+
 #include "low-can-binding.hpp"
 
 // TODO actual max is 32 but dropped to 24 for memory considerations
@@ -37,6 +39,7 @@
 #define CAN_ACTIVE_TIMEOUT_S 30
 
 class can_bus_dev_t;
+class diagnostic_manager_t;
 
 /** 
  * @class can_bus_t
@@ -105,10 +108,12 @@ class can_bus_dev_t {
 		int can_socket_; /*!< socket handler for the can 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 */
-		
+
+		diagnostic_manager_t diagnostic_manager_; /*!< diagnostic_manager_t diagnostic_manager_ - A diagnostic_manager_t object instance
+												   * that will handle diagnostic obd2 protocol requests and responses.*/
+
 		std::thread th_reading_; /*!< Thread handling read the socket can device filling can_message_q_ queue of can_bus_t */
 		bool is_running_; /*!< boolean telling whether or not reading is running or not */
-		
 		void can_reader(can_bus_t& can_bus);
 
 	public:
@@ -116,7 +121,6 @@ class can_bus_dev_t {
 
 		int open();
 		int close();
-		
 
 		void start_reading(can_bus_t& can_bus);
 
diff --git a/src/diagnostic/diagnostic-manager.cpp b/src/diagnostic/diagnostic-manager.cpp
new file mode 100644
index 00000000..501c05a5
--- /dev/null
+++ b/src/diagnostic/diagnostic-manager.cpp
@@ -0,0 +1,43 @@
+/*
+ * 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 "obd2/diagnostic-manager.hpp"
+
+#include "low-can-binding.hpp"
+
+diagnostic_manager_t::diagnostic_manager_t(can_bus_dev_t& bus)
+	: bus_(bus)
+{}
+
+void diagnostic_manager_t::shims_logger(const char* m)
+{
+	DEBUG(binder_interface, "%s", m);
+}
+
+void diagnostic_manager_t::shims_timer()
+{}
+
+/**
+ * @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()
+{
+	DiagnosticShims shims_ = diagnostic_init_shims(shims_logger, bus_.send_can_message, NULL);
+	initialized_ = true;
+}
\ No newline at end of file
diff --git a/src/diagnostic/diagnostic-manager.hpp b/src/diagnostic/diagnostic-manager.hpp
new file mode 100644
index 00000000..8aa9240c
--- /dev/null
+++ b/src/diagnostic/diagnostic-manager.hpp
@@ -0,0 +1,77 @@
+/*
+ * 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 "uds/uds.h"
+#include "can/can-bus.hpp"
+#include "can/can-message.hpp"
+#include "obd2/active-diagnostic-request.hpp"
+
+#include "low-can-binding.hpp"
+
+/* Private: 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()
+
+/**
+ * @brief The core structure for running the diagnostics module on the VI.
+ *
+ * @desc This stores details about the active requests and shims required to connect
+ * the diagnostics library to the VI's CAN peripheral.
+ */
+class diagnostic_manager_t {
+	protected:
+	void shims_logger(const char* m);
+	void shims_timer();
+
+	private:
+		DiagnosticShims shims_; /*!< shims_ - An array of shim functions for each CAN bus that plug the diagnostics
+								 * library (uds-c) into the VI's CAN peripheral.*/
+		can_bus_dev_t* bus_; /*!< bus_ - A reference to the CAN bus that should be used for all standard OBD-II requests, if the bus is not
+							  * explicitly spcified in the request. If NULL, all requests require an explicit bus.*/
+		std::queue<active_diagnostic_request_t> recurringRequests_; /*!< recurringRequests - A queue of active, recurring diagnostic requests. When
+																  * a response is received for a recurring request or it times out, it is
+																  * popped from the queue and pushed onto the back. */
+		std::vector<active_diagnostic_request_t> nonrecurringRequests_; /*!< 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 from this list and placed back in the free list.*/
+		std::vector<active_diagnostic_request_t> freeRequestEntries_; /*!< freeRequestEntries - A list of all available slots for active diagnostic
+																	* requests. This free list is backed by statically allocated entries in
+																	* the requestListEntries attribute.*/
+		std::vector<active_diagnostic_request_t> requestListEntries_[50]; /*!< requestListEntries - Static allocation for all active diagnostic requests.*/
+
+		bool initialized_; /*!< * initialized - True if the DiagnosticsManager has been initialized with shims. It will interface with the uds-c lib*/
+
+	public:
+		diagnostic_manager_t(can_bus_dev_t& bus);
+		void init_diagnostic_shims();
+ 
+		void checkSupportedPids(const active_diagnostic_request_t& request,
+		const DiagnosticResponse& response, float parsedPayload);
+
+		bool addRecurringRequest(DiagnosticRequest* request, const char* name,
+			bool waitForMultipleResponses, const DiagnosticResponseDecoder decoder,
+			const DiagnosticResponseCallback callback, float frequencyHz);
+
+		void reset();
+
+		void add_request(int pid);
+};
diff --git a/src/diagnostic/diagnostic-message.cpp b/src/diagnostic/diagnostic-message.cpp
index 71b0f7d7..707b314f 100644
--- a/src/diagnostic/diagnostic-message.cpp
+++ b/src/diagnostic/diagnostic-message.cpp
@@ -105,22 +105,9 @@ void obd2_signals_t::find_obd2_signals(const openxc_DynamicField &key, std::vect
 	DEBUG(binder_interface, "Found %d signal(s)", (int)found_signals.size());
 }
 
-uint32_t get_signal_id(const obd2_signals_t& sig)
-{
-	return (uint32_t)sig.pid;
-}
-
-void shims_logger(const char* m, const struct afb_binding_interface *interface)
-{
-	DEBUG(interface, "%s", m);
-}
-
-void shims_timer()
-{
-}
-
 bool obd2_signals_t::is_obd2_response(can_message_t can_message)
 {
+	/*
 	if(can_message.get_id() >= 0x7E8 && can_message.get_id() <= 0x7EF)
 	{
 		openxc_VehicleMessage message = {0};