/* * Copyright (C) 2015, 2016 "IoT.bzh" * Author "Romain Forlot" * * 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 #include #include #include "diagnostic-manager.hpp" #include "../utils/openxc-utils.hpp" #include "../utils/signals.hpp" #include "../binding/application.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_ = application_t::instance().get_diagnostic_bus(); init_diagnostic_shims(); reset(); initialized_ = true; AFB_DEBUG("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); AFB_DEBUG("Shims initialized"); } /// @brief Force cleanup all active requests. void diagnostic_manager_t::reset() { AFB_DEBUG("Clearing existing diagnostic requests"); cleanup_active_requests(true); } /// @brief send function use by diagnostic library. It will open a BCM CAN socket TX_SETUP type. /// That socket will send cyclic messages configured from a diagnostic request. /// /// @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) { diagnostic_manager_t& dm = application_t::instance().get_diagnostic_manager(); active_diagnostic_request_t* current_adr = dm.get_last_recurring_requests(); utils::socketcan_bcm_t& tx_socket = current_adr->get_socket(); // Make sure that socket has been opened. if(! tx_socket) tx_socket.open( dm.get_bus_device_name()); struct utils::simple_bcm_msg bcm_msg; struct can_frame cfd; memset(&cfd, 0, sizeof(cfd)); memset(&bcm_msg.msg_head, 0, sizeof(bcm_msg.msg_head)); struct timeval freq = current_adr->get_frequency_clock().get_timeval_from_period(); bcm_msg.msg_head.opcode = TX_SETUP; bcm_msg.msg_head.can_id = arbitration_id; bcm_msg.msg_head.flags = SETTIMER|STARTTIMER|TX_CP_CAN_ID; bcm_msg.msg_head.ival2.tv_sec = freq.tv_sec; bcm_msg.msg_head.ival2.tv_usec = freq.tv_usec; bcm_msg.msg_head.nframes = 1; cfd.can_dlc = size; ::memcpy(cfd.data, data, size); bcm_msg.frames = cfd; tx_socket << bcm_msg; if(tx_socket) return true; 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); AFB_DEBUG("%s", buffer); va_end(args); } /// @brief The type signature for a... OpenXC TODO: not used yet. void diagnostic_manager_t::shims_timer() {} const std::string diagnostic_manager_t::get_bus_name() const { return bus_; } const std::string diagnostic_manager_t::get_bus_device_name() const { return application_t::instance().get_can_bus_manager() .get_can_device_name(bus_); } active_diagnostic_request_t* diagnostic_manager_t::get_last_recurring_requests() const { return recurring_requests_.back(); } /// @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& requests_list) { auto i = std::find(requests_list.begin(), requests_list.end(), entry); if ( i != requests_list.end()) requests_list.erase(i); } /// @brief Free memory allocated on active_diagnostic_request_t object and close the socket. void diagnostic_manager_t::cancel_request(active_diagnostic_request_t* entry) { entry->get_socket().close(); delete entry; entry = nullptr; } /// @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(entry != nullptr && (force || entry->response_received())) { char request_string[128] = {0}; diagnostic_request_to_string(&entr

FILESEXTRAPATHS_prepend := "${THISDIR}/files:"

require recipes-kernel/linux/linux-yocto-agl.inc

# Add ADSP patch to enable and add sound hardware abstraction
SRC_URI_append = " \
    file://0004-ADSP-enable-and-add-sound-hardware-abstraction.patch \
"

AGL_KCONFIG_FRAGMENTS += "namespace_fix.cfg"

# For Xen
AGL_KCONFIG_FRAGMENTS += " \
    ${@bb.utils.contains('AGL_XEN_WANTED','1','xen-be.cfg','',d)} \
"
SRC_URI_append_m3ulcb = " \
    ${@bb.utils.contains('AGL_XEN_WANTED','1','file://r8a7796-m3ulcb-xen.dts;subdir=git/arch/${ARCH}/boot/dts/renesas','',d)} \
"
KERNEL_DEVICETREE_append_m3ulcb = " \
    ${@bb.utils.contains('AGL_XEN_WANTED','1','renesas/r8a7796-m3ulcb-xen.dtb','',d)} \
"

ic 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( entry->get_timeout_clock().get_time_function()()); } 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; }