X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fdiagnostic%2Fdiagnostic-manager.cpp;h=31eed0e2423716c7c7f623ba34fd0fcce4508cdd;hb=53cd923a034162273fea2f4fb045b28686f51df5;hp=e7293ca635ddd208f9d3db48cf9d461a053271ca;hpb=76df856e0df1b67770038e657f526f915c11a140;p=apps%2Flow-level-can-service.git diff --git a/src/diagnostic/diagnostic-manager.cpp b/src/diagnostic/diagnostic-manager.cpp index e7293ca..31eed0e 100644 --- a/src/diagnostic/diagnostic-manager.cpp +++ b/src/diagnostic/diagnostic-manager.cpp @@ -26,18 +26,17 @@ #define MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ 10 #define MAX_SIMULTANEOUS_DIAG_REQUESTS 50 -#define MAX_REQUEST_ENTRIES 50 #define TIMERFD_ACCURACY 0 #define MICRO 1000000 diagnostic_manager_t::diagnostic_manager_t() - : request_list_entries_(MAX_REQUEST_ENTRIES, new active_diagnostic_request_t()), initialized_{false} + : initialized_{false} {} -bool diagnostic_manager_t::initialize(std::shared_ptr cbd) +bool diagnostic_manager_t::initialize() { // Mandatory to set the bus before intiliaze shims. - bus_ = cbd; + bus_ = configuration_t::instance().get_diagnostic_bus(); init_diagnostic_shims(); reset(); @@ -65,12 +64,6 @@ void diagnostic_manager_t::reset() DEBUG(binder_interface, "Clearing existing diagnostic requests"); cleanup_active_requests(true); } - - for(uint8_t i = 0; i < MAX_REQUEST_ENTRIES; i++) - { - free_request_entries_.push_back(request_list_entries_.back()); - request_list_entries_.pop_back(); - } } @@ -85,7 +78,7 @@ void diagnostic_manager_t::find_and_erase(active_diagnostic_request_t* entry, st /// CAN filters it used. void diagnostic_manager_t::cancel_request(active_diagnostic_request_t* entry) { - free_request_entries_.push_back(entry); + /* TODO: implement acceptance filters. if(entry.arbitration_id_ == OBD2_FUNCTIONAL_BROADCAST_ID) { for(uint32_t filter = OBD2_FUNCTIONAL_RESPONSE_START; @@ -118,43 +111,41 @@ void diagnostic_manager_t::cleanup_request(active_diagnostic_request_t* entry, b find_and_erase(entry, recurring_requests_); if(force) cancel_request(entry); - else - { - DEBUG(binder_interface, "Moving completed recurring request to the back of the queue: %s", request_string); - recurring_requests_.push_back(entry); - } } else { - DEBUG(binder_interface, "Cancelling completed, non-recurring request: %s", request_string); + 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 the request list, move as many to the free list as possible +/// @brief Clean up the request list void diagnostic_manager_t::cleanup_active_requests(bool force) { for(auto& entry : non_recurring_requests_) - cleanup_request(entry, force); + if (entry != nullptr) + cleanup_request(entry, force); for(auto& entry : recurring_requests_) - cleanup_request(entry, force); + if (entry != nullptr) + cleanup_request(entry, force); } -/// @brief Note that this pops it off of whichver list it was on and returns it, so make -/// sure to add it to some other list or it'll be lost. +/// @brief Will return the active_diagnostic_request_t pointer of found request or nullptr if +/// not found. active_diagnostic_request_t* diagnostic_manager_t::find_recurring_request(const DiagnosticRequest* request) { for (auto& entry : recurring_requests_) { - active_diagnostic_request_t* candidate = entry; - if(diagnostic_request_equals(&candidate->get_handle()->request, request)) + if(entry != nullptr) { - find_and_erase(entry, recurring_requests_); - return entry; - break; + if(diagnostic_request_equals(&entry->get_handle()->request, request)) + { + return entry; + break; + } } } return nullptr; @@ -162,17 +153,7 @@ active_diagnostic_request_t* diagnostic_manager_t::find_recurring_request(const std::shared_ptr diagnostic_manager_t::get_can_bus_dev() { - return bus_; -} - -active_diagnostic_request_t* diagnostic_manager_t::get_free_entry() -{ - if (free_request_entries_.empty()) - return nullptr; - - active_diagnostic_request_t* adr = free_request_entries_.back(); - free_request_entries_.pop_back(); - return adr; + return can_bus_t::get_can_device(bus_); } bool diagnostic_manager_t::add_request(DiagnosticRequest* request, const std::string name, @@ -182,13 +163,12 @@ bool diagnostic_manager_t::add_request(DiagnosticRequest* request, const std::st cleanup_active_requests(false); bool added = true; - active_diagnostic_request_t* entry = get_free_entry(); - if (entry != nullptr) + if (non_recurring_requests_.size() <= MAX_SIMULTANEOUS_DIAG_REQUESTS) { // TODO: implement Acceptance Filter // if(updateRequiredAcceptanceFilters(bus, request)) { - entry = new active_diagnostic_request_t(bus_, request, name, + 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); @@ -198,13 +178,14 @@ bool diagnostic_manager_t::add_request(DiagnosticRequest* request, const std::st find_and_erase(entry, non_recurring_requests_); DEBUG(binder_interface, "Added one-time diagnostic request on bus %s: %s", - bus_->get_device_name(), request_string); + bus_, request_string); non_recurring_requests_.push_back(entry); } else { - WARNING(binder_interface, "There isn't enough request entry. Vector exhausted %d/%d", (int)request_list_entries_.size(), (int)request_list_entries_.max_size()); + WARNING(binder_interface, "There isn't enough request entry. Vector exhausted %d/%d", (int)non_recurring_requests_.size()); + non_recurring_requests_.resize(MAX_SIMULTANEOUS_DIAG_REQUESTS); added = false; } return added; @@ -232,75 +213,47 @@ bool diagnostic_manager_t::add_recurring_request(DiagnosticRequest* request, con bool added = true; if(find_recurring_request(request) == nullptr) { - active_diagnostic_request_t* entry = get_free_entry(); - - if(entry != nullptr) + if(recurring_requests_.size() <= MAX_SIMULTANEOUS_DIAG_REQUESTS) { sd_event_source *source; // TODO: implement Acceptance Filter //if(updateRequiredAcceptanceFilters(bus, request)) { - entry = new active_diagnostic_request_t(bus_, request, name, - wait_for_multiple_responses, decoder, callback, frequencyHz); - 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, recurring_requests_); - DEBUG(binder_interface, "Added recurring diagnostic request (freq: %f) on bus %s: %s", - frequencyHz, bus_->get_device_name().c_str(), request_string); - - uint64_t usec; - usec = sd_event_now(afb_daemon_get_event_loop(binder_interface->daemon), CLOCK_MONOTONIC, &usec) + (uint64_t)(frequency_clock_t::frequency_to_period(frequencyHz)*MICRO); - if(sd_event_add_time(afb_daemon_get_event_loop(binder_interface->daemon), &source, - CLOCK_MONOTONIC, usec, TIMERFD_ACCURACY, send_request, request) >= 0) - recurring_requests_.push_back(entry); - else - { - ERROR(binder_interface, "add_recurring_request: Request fails to be schedule through event loop"); - free_request_entries_.push_back(entry); - added = false; - } + 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); + + char request_string[128] = {0}; + diagnostic_request_to_string(&entry->get_handle()->request, request_string, + sizeof(request_string)); + + DEBUG(binder_interface, "add_recurring_request: Added recurring diagnostic request (freq: %f) on bus %s: %s", + frequencyHz, bus_.c_str(), request_string); + + uint64_t usec; + sd_event_now(afb_daemon_get_event_loop(binder_interface->daemon), CLOCK_MONOTONIC, &usec); + if(sd_event_add_time(afb_daemon_get_event_loop(binder_interface->daemon), &source, + CLOCK_MONOTONIC, 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, "There isn't enough request entry. Vector exhausted %d/%d", (int)request_list_entries_.size(), (int)request_list_entries_.max_size()); - free_request_entries_.push_back(entry); + 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, "Can't add request, one already exists with same key"); + DEBUG(binder_interface, "add_recurring_request: Can't add request, one already exists with same key"); added = false; } return added; } -bool diagnostic_manager_t::is_diagnostic_response(const active_diagnostic_request_t& adr, const can_message_t& cm) const -{ - if(cm.get_id() == adr.get_id() + DIAGNOSTIC_RESPONSE_ARBITRATION_ID_OFFSET) - return true; - DEBUG(binder_interface, "Doesn't find an active diagnostic request that matches."); - return false; -} - -active_diagnostic_request_t* diagnostic_manager_t::is_diagnostic_response(const can_message_t& can_message) -{ - for (auto& entry : non_recurring_requests_) - { - if(is_diagnostic_response(*entry, can_message)) - return entry; - } - - for (auto& entry : recurring_requests_) - { - if(is_diagnostic_response(*entry, can_message)) - return entry; - } - return nullptr; -} openxc_VehicleMessage diagnostic_manager_t::relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response) const { @@ -365,35 +318,49 @@ int diagnostic_manager_t::send_request(sd_event_source *s, uint64_t usec, void * DiagnosticRequest* request = (DiagnosticRequest*)userdata; active_diagnostic_request_t* adr = dm.find_recurring_request(request); - if(adr != nullptr && adr->get_can_bus_dev() == dm.get_can_bus_dev() && adr->should_send() && - dm.clear_to_send(adr)) +// if(adr != nullptr && adr->get_can_bus_dev() == dm.get_can_bus_dev() && adr->should_send() && +// dm.clear_to_send(adr)) + if(adr != nullptr && adr->get_can_bus_dev() == dm.get_can_bus_dev()) { - DEBUG(binder_interface, "Got active_diagnostic_request from recurring_requests_ queue."); adr->get_frequency_clock().tick(); - start_diagnostic_request(&dm.get_shims(), adr->get_handle()); + start_diagnostic_request(&dm.shims_, adr->get_handle()); if(adr->get_handle()->completed && !adr->get_handle()->success) { - DEBUG(binder_interface, "Fatal error sending diagnostic request"); + DEBUG(binder_interface, "send_request: Fatal error sending diagnostic request"); return 0; } adr->get_timeout_clock().tick(); adr->set_in_flight(true); - return 1; - usec = usec + (uint64_t)(frequency_clock_t::frequency_to_period(adr->get_frequency_clock().get_frequency())*MICRO); - DEBUG(binder_interface, "send_request: usec: %d", usec); - if(sd_event_source_set_time(s, usec) >= 0) - if(sd_event_source_set_enabled(s, SD_EVENT_ON) >= 0) - { - dm.recurring_requests_.push_back(adr); - return 1; - } + if(adr->get_recurring()) + { + usec = usec + (uint64_t)(frequency_clock_t::frequency_to_period(adr->get_frequency_clock().get_frequency())*MICRO); + 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+1000000) >= 0) + if(sd_event_source_set_enabled(s, SD_EVENT_ON) >= 0) + return 1; + } } - dm.recurring_requests_.push_back(adr); + sd_event_source_unref(s); ERROR(binder_interface, "send_request: Something goes wrong when submitting a new request to the CAN bus"); return -1; } + +/// @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; +} + DiagnosticShims& diagnostic_manager_t::get_shims() { return shims_; @@ -401,15 +368,20 @@ DiagnosticShims& diagnostic_manager_t::get_shims() 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 = configuration_t::instance().get_diagnostic_manager().get_can_bus_dev(); + std::shared_ptr can_bus_dev = can_bus_t::get_can_device(configuration_t::instance().get_diagnostic_manager().bus_); return can_bus_dev->shims_send(arbitration_id, data, size); } -void diagnostic_manager_t::shims_logger(const char* m, ...) +void diagnostic_manager_t::shims_logger(const char* format, ...) { - DEBUG(binder_interface, "%s", m); + va_list args; + va_start(args, format); + + char buffer[256]; + vsnprintf(buffer, 256, format, args); + + DEBUG(binder_interface, "shims_logger: %s", buffer); } void diagnostic_manager_t::shims_timer() {} -