#include "active-diagnostic-request.hpp"
-#include "../configuration.hpp"
+#include "../binding/application.hpp"
#define ERROR_PID 0xFF
callback_ = adr.callback_;
recurring_ = adr.recurring_;
wait_for_multiple_responses_ = adr.wait_for_multiple_responses_;
- in_flight_ = adr.in_flight_;
frequency_clock_ = adr.frequency_clock_;
timeout_clock_ = adr.timeout_clock_;
+ socket_ = adr.socket_;
}
return *this;
}
active_diagnostic_request_t::active_diagnostic_request_t()
- : bus_{nullptr}, id_{0}, handle_{nullptr}, name_{""},
- decoder_{nullptr}, callback_{nullptr}, recurring_{false}, wait_for_multiple_responses_{false},
- in_flight_{false}, frequency_clock_{frequency_clock_t()}, timeout_clock_{frequency_clock_t()}
+ : bus_{nullptr},
+ id_{0},
+ handle_{nullptr},
+ name_{""},
+ decoder_{nullptr},
+ callback_{nullptr},
+ recurring_{false},
+ wait_for_multiple_responses_{false},
+ frequency_clock_{frequency_clock_t()},
+ timeout_clock_{frequency_clock_t()},
+ socket_{}
{}
-active_diagnostic_request_t::active_diagnostic_request_t(const std::string& bus, DiagnosticRequest* request,
- const std::string& name, bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder,
- const DiagnosticResponseCallback callback, float frequencyHz)
- : bus_{bus}, id_{request->arbitration_id}, handle_{nullptr}, name_{name},
- decoder_{decoder}, callback_{callback}, recurring_{frequencyHz ? true : false}, wait_for_multiple_responses_{wait_for_multiple_responses},
- in_flight_{false}, frequency_clock_{frequency_clock_t(frequencyHz)}, timeout_clock_{frequency_clock_t(10)}
+active_diagnostic_request_t::active_diagnostic_request_t(const std::string& bus, uint32_t id,
+ const std::string& name,
+ bool wait_for_multiple_responses,
+ const DiagnosticResponseDecoder decoder,
+ const DiagnosticResponseCallback callback,
+ float frequencyHz)
+ : bus_{bus},
+ id_{id},
+ handle_{nullptr},
+ name_{name},
+ decoder_{decoder},
+ callback_{callback},
+ recurring_{frequencyHz ? true : false},
+ wait_for_multiple_responses_{wait_for_multiple_responses},
+ frequency_clock_{frequency_clock_t(frequencyHz)},
+ timeout_clock_{frequency_clock_t(10)},
+ socket_{}
{}
-uint32_t active_diagnostic_request_t::get_id() const
+active_diagnostic_request_t::~active_diagnostic_request_t()
{
- return id_;
+ socket_.close();
+ delete handle_;
+ handle_ = nullptr;
}
-const std::shared_ptr<can_bus_dev_t> active_diagnostic_request_t::get_can_bus_dev() const
+uint32_t active_diagnostic_request_t::get_id() const
{
- return can_bus_t::get_can_device(bus_);
+ return id_;
}
uint16_t active_diagnostic_request_t::get_pid() const
return recurring_;
}
-bool active_diagnostic_request_t::get_in_flight() const
-{
- return in_flight_;
-}
-
frequency_clock_t& active_diagnostic_request_t::get_frequency_clock()
{
return frequency_clock_;
return timeout_clock_;
}
-void active_diagnostic_request_t::set_handle(DiagnosticShims& shims, DiagnosticRequest* request)
+utils::socketcan_bcm_t& active_diagnostic_request_t::get_socket()
{
- handle_ = new DiagnosticRequestHandle(generate_diagnostic_request(&shims, request, nullptr));
+ return socket_;
}
-void active_diagnostic_request_t::set_in_flight(bool val)
+void active_diagnostic_request_t::set_handle(DiagnosticShims& shims, DiagnosticRequest* request)
{
- in_flight_ = val;
+ handle_ = new DiagnosticRequestHandle(generate_diagnostic_request(&shims, request, nullptr));
}
///
return false;
}
-/// @brief Check is the request should be sent or not
-///
-/// @return true if the request is not running or recurring nor completed,
-/// or it's recurring, its clock elapsed
-/// so it's time to send another one.
-bool active_diagnostic_request_t::should_send()
-{
- return !in_flight_ && ( (!recurring_ && !request_completed()) ||
- (recurring_ && frequency_clock_.elapsed(true)) );
-}
-
-/// @brief check if the timeout clock has elapsed
-///
-/// @return true if elapsed, so it is a timeout, else false.
-bool active_diagnostic_request_t::timed_out()
-{
- // don't use staggered start with the timeout clock
- return timeout_clock_.elapsed(false);
-}
-
/// @brief Returns true if a sufficient response has been received for a
/// diagnostic request.
///
bool active_diagnostic_request_t::response_received() const
{
return !wait_for_multiple_responses_ &&
- handle_->completed;
-}
-
-/// @brief Returns true if the request has timed out waiting for a response,
-/// or a sufficient number of responses has been received.
-bool active_diagnostic_request_t::request_completed()
-{
- return response_received() ||
- (timed_out() && diagnostic_request_sent(handle_));
+ handle_->completed && handle_->success;
}