#include "../utils/openxc-utils.hpp"
#include "../utils/signals.hpp"
-#include "../binding/configuration.hpp"
+#include "../binding/application.hpp"
#define MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ 10
#define MAX_SIMULTANEOUS_DIAG_REQUESTS 50
#define MICRO 1000000
diagnostic_manager_t::diagnostic_manager_t()
- : initialized_{false}
+ : initialized_{false}, event_source_{nullptr}
{}
/// @brief Diagnostic manager isn't initialized at launch but after
bool diagnostic_manager_t::initialize()
{
// Mandatory to set the bus before intialize shims.
- bus_ = configuration_t::instance().get_diagnostic_bus();
+ bus_ = application_t::instance().get_diagnostic_bus();
init_diagnostic_shims();
event_source_ = nullptr;
return initialized_;
}
-void diagnostic_manager_t::read_socket()
-{
- can_message_t msg;
- can_bus_t& cbm = configuration_t::instance().get_can_bus_manager();
- socket_ >> msg;
- std::lock_guard<std::mutex> can_message_lock(cbm.get_can_message_mutex());
- { cbm.push_new_can_message(msg); }
- cbm.get_new_can_message_cv().notify_one();
-}
-
utils::socketcan_bcm_t& diagnostic_manager_t::get_socket()
{
return socket_;
/// listens on CAN ID range 7E8 - 7EF affected to the OBD2 communications.
///
/// @return -1 or negative value on error, 0 if ok.
-int diagnostic_manager_t::add_rx_filter(uint32_t can_id)
+int diagnostic_manager_t::create_rx_filter(uint32_t can_id, float frequency)
{
// Make sure that socket has been opened.
if(! socket_)
- socket_.open(bus_);
+ socket_.open(get_bus_device_name());
struct utils::simple_bcm_msg bcm_msg;
- memset(&bcm_msg.msg_head, 0, sizeof(bcm_msg.msg_head));
+ memset(&bcm_msg, 0, sizeof(bcm_msg));
- const struct timeval freq = recurring_requests_.back()->get_timeout_clock().get_timeval_from_period();
+ const struct timeval freq = (frequency == recurring_requests_.back()->get_frequency_clock().get_frequency() ) ?
+ recurring_requests_.back()->get_frequency_clock().get_timeval_from_period() : frequency_clock_t(frequency).get_timeval_from_period();
bcm_msg.msg_head.opcode = RX_SETUP;
bcm_msg.msg_head.flags = SETTIMER|RX_FILTER_ID;
/// @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 = configuration_t::instance().get_diagnostic_manager();
+ 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_can_bus());
+ dm.get_bus_device_name());
struct utils::simple_bcm_msg bcm_msg;
struct can_frame cfd;
vsnprintf(buffer, 256, format, args);
DEBUG(binder_interface, "%s: %s", __FUNCTION__, buffer);
+ va_end(args);
}
/// @brief The type signature for a... OpenXC TODO: not used yet.
void diagnostic_manager_t::shims_timer()
{}
-std::string diagnostic_manager_t::get_can_bus()
+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();
return shims_;
}
+bool diagnostic_manager_t::socket_close()
+{
+ if(non_recurring_requests_.empty() && recurring_requests_.empty())
+ {
+ socket_.close();
+ return true;
+ }
+ return false;
+}
+
/// @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
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
request_string, sizeof(request_string));
if(force && entry->get_recurring())
{
- find_and_erase(entry, recurring_requests_);
cancel_request(entry);
+ find_and_erase(entry, recurring_requests_);
DEBUG(binder_interface, "%s: Cancelling completed, recurring request: %s", __FUNCTION__, request_string);
}
- else
+ else if (!entry->get_recurring())
{
DEBUG(binder_interface, "%s: Cancelling completed, non-recurring request: %s", __FUNCTION__, request_string);
- find_and_erase(entry, non_recurring_requests_);
cancel_request(entry);
+ find_and_erase(entry, non_recurring_requests_);
}
+ socket_close();
}
}
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
if(entry != nullptr)
{
if(diagnostic_request_equals(&entry->get_handle()->request, request))
- {
- return entry;
- break;
- }
+ {return entry;}
}
}
return nullptr;
/// @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,
-active_diagnostic_request_t* diagnostic_manager_t::add_request(DiagnosticRequest* request, const std::string name,
+active_diagnostic_request_t* diagnostic_manager_t::add_request(DiagnosticRequest* request, const std::string& name,
bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder,
const DiagnosticResponseCallback callback)
{
diagnostic_request_to_string(&entry->get_handle()->request, request_string,
sizeof(request_string));
- find_and_erase(entry, non_recurring_requests_);
+ // Erase any existing request not already cleaned.
+ cleanup_request(entry, true);
DEBUG(binder_interface, "%s: Added one-time diagnostic request on bus %s: %s", __FUNCTION__,
bus_.c_str(), request_string);
recurring_requests_.push_back(entry);
entry->set_handle(shims_, request);
- if(add_rx_filter(OBD2_FUNCTIONAL_BROADCAST_ID) < 0)
- { recurring_requests_.pop_back(); }
+ if(create_rx_filter(OBD2_FUNCTIONAL_BROADCAST_ID, frequencyHz) < 0)
+ {
+ recurring_requests_.pop_back();
+ delete entry;
+ entry = nullptr;
+ }
else
{
start_diagnostic_request(&shims_, entry->get_handle());
&event_source_,
socket_.socket(),
EPOLLIN,
- read_diagnostic_message,
+ read_message,
nullptr) < 0)
{
cleanup_request(entry, true);
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().tick(
+ entry->get_timeout_clock().get_time_function()());
}
return build_VehicleMessage();