###########################################################################
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)
#include "can/can-decoder.hpp"
#include "utils/openxc-utils.hpp"
+#include "obd2/diagnostic-manager.hpp"
extern "C"
{
*
* @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
#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
#define CAN_ACTIVE_TIMEOUT_S 30
class can_bus_dev_t;
+class diagnostic_manager_t;
/**
* @class can_bus_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:
int open();
int close();
-
void start_reading(can_bus_t& can_bus);
--- /dev/null
+/*
+ * 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
--- /dev/null
+/*
+ * 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);
+};
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};
Code Review / apps / low-level-can-service.git / commitdiff