summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorRomain Forlot <romain.forlot@iot.bzh>2017-03-15 23:30:37 +0100
committerRomain Forlot <romain.forlot@iot.bzh>2017-03-16 17:21:57 +0100
commit7175a87b640b9920e666bce53f46002ac19d4c21 (patch)
tree9381404327f826e35b33626ee379cd37b0b9dde3 /src
parent5d7fbc236e5778a54c39afd51ed353c0e8761dec (diff)
Finalization of decoding part of diagnostic messages.
Diagnostic request must have a name to be subscribed. Else, we can't decode or event push for now. Change-Id: I0901a71da31320d8598e512614437aceb552713d Signed-off-by: Romain Forlot <romain.forlot@iot.bzh>
Diffstat (limited to 'src')
-rw-r--r--src/can/can-bus.cpp39
-rw-r--r--src/can/can-bus.hpp2
-rw-r--r--src/diagnostic/diagnostic-manager.cpp116
-rw-r--r--src/diagnostic/diagnostic-manager.hpp12
4 files changed, 102 insertions, 67 deletions
diff --git a/src/can/can-bus.cpp b/src/can/can-bus.cpp
index 18417f9..c08d1e8 100644
--- a/src/can/can-bus.cpp
+++ b/src/can/can-bus.cpp
@@ -115,41 +115,21 @@ int can_bus_t::process_can_signals(can_message_t& can_message)
*
* @return How many signals has been decoded.
*/
-int can_bus_t::process_diagnostic_signals(active_diagnostic_request_t* entry, const can_message_t& can_message)
+int can_bus_t::process_diagnostic_signals(diagnostic_manager_t& manager, const can_message_t& can_message)
{
int processed_signals = 0;
- openxc_VehicleMessage vehicle_message;
-
- diagnostic_manager_t& manager = configuration_t::instance().get_diagnostic_manager();
std::lock_guard<std::mutex> subscribed_signals_lock(get_subscribed_signals_mutex());
std::map<std::string, struct afb_event>& s = get_subscribed_signals();
- if( s.find(entry->get_name()) != s.end() && afb_event_is_valid(s[entry->get_name()]))
+ openxc_VehicleMessage vehicle_message = manager.find_and_decode_adr(can_message);
+ if( (vehicle_message.has_simple_message && vehicle_message.simple_message.has_name) &&
+ (s.find(vehicle_message.simple_message.name) != s.end() && afb_event_is_valid(s[vehicle_message.simple_message.name])))
{
- if(manager.get_can_bus_dev() == entry->get_can_bus_dev() && entry->get_in_flight())
- {
- DiagnosticResponse response = diagnostic_receive_can_frame(
- // TODO: openXC todo task: eek, is bus address and array index this tightly coupled?
- &manager.get_shims(),
- entry->get_handle(), can_message.get_id(), can_message.get_data(), can_message.get_length());
- if(response.completed && entry->get_handle()->completed)
- {
- if(entry->get_handle()->success)
- {
- vehicle_message = manager.relay_diagnostic_response(entry, response);
- std::lock_guard<std::mutex> decoded_can_message_lock(decoded_can_message_mutex_);
- push_new_vehicle_message(vehicle_message);
- new_decoded_can_message_.notify_one();
- processed_signals++;
- }
- else
- DEBUG(binder_interface, "process_diagnostic_signals: Fatal error sending or receiving diagnostic request");
- }
- else if(!response.completed && response.multi_frame)
- // Reset the timeout clock while completing the multi-frame receive
- entry->get_timeout_clock().tick();
- }
+ std::lock_guard<std::mutex> decoded_can_message_lock(decoded_can_message_mutex_);
+ push_new_vehicle_message(vehicle_message);
+ new_decoded_can_message_.notify_one();
+ processed_signals++;
}
return processed_signals;
@@ -180,8 +160,7 @@ void can_bus_t::can_decode_message()
can_message = next_can_message();
if(configuration_t::instance().get_diagnostic_manager().is_diagnostic_response(can_message))
- if(adr != nullptr)
- process_diagnostic_signals(adr, can_message);
+ process_diagnostic_signals(configuration_t::instance().get_diagnostic_manager(), can_message);
else
process_can_signals(can_message);
}
diff --git a/src/can/can-bus.hpp b/src/can/can-bus.hpp
index a51dfb1..bedc05e 100644
--- a/src/can/can-bus.hpp
+++ b/src/can/can-bus.hpp
@@ -81,7 +81,7 @@ public:
void stop_threads();
int process_can_signals(can_message_t& can_message);
- int process_diagnostic_signals(active_diagnostic_request_t* adr, const can_message_t& can_message);
+ int process_diagnostic_signals(diagnostic_manager_t& manager, const can_message_t& can_message);
can_message_t next_can_message();
void push_new_can_message(const can_message_t& can_msg);
diff --git a/src/diagnostic/diagnostic-manager.cpp b/src/diagnostic/diagnostic-manager.cpp
index 31eed0e..31fbf0b 100644
--- a/src/diagnostic/diagnostic-manager.cpp
+++ b/src/diagnostic/diagnostic-manager.cpp
@@ -255,38 +255,6 @@ bool diagnostic_manager_t::add_recurring_request(DiagnosticRequest* request, con
}
-openxc_VehicleMessage diagnostic_manager_t::relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response) const
-{
- openxc_VehicleMessage message;
- float value = (float)diagnostic_payload_to_integer(&response);
- if(adr->get_decoder() != nullptr)
- {
- value = adr->get_decoder()(&response, value);
- }
-
- if((response.success && strnlen(adr->get_name().c_str(), adr->get_name().size())) > 0)
- {
- // If name, include 'value' instead of payload, and leave of response
- // details.
- message = build_VehicleMessage(build_SimpleMessage(adr->get_name(), build_DynamicField(value)));
- }
- else
- {
- // If no name, send full details of response but still include 'value'
- // instead of 'payload' if they provided a decoder. The one case you
- // can't get is the full detailed response with 'value'. We could add
- // another parameter for that but it's onerous to carry that around.
- message = build_VehicleMessage(adr, response, value);
- }
-
- if(adr->get_callback() != nullptr)
- {
- adr->get_callback()(adr, &response, value);
- }
-
- return message;
-}
-
bool diagnostic_manager_t::conflicting(active_diagnostic_request_t* request, active_diagnostic_request_t* candidate) const
{
return (candidate->get_in_flight() && candidate != request &&
@@ -346,6 +314,90 @@ int diagnostic_manager_t::send_request(sd_event_source *s, uint64_t usec, void *
return -1;
}
+openxc_VehicleMessage diagnostic_manager_t::relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response) const
+{
+ openxc_VehicleMessage message = build_VehicleMessage();
+ float value = (float)diagnostic_payload_to_integer(&response);
+ if(adr->get_decoder() != nullptr)
+ {
+ value = adr->get_decoder()(&response, value);
+ }
+
+ if((response.success && strnlen(adr->get_name().c_str(), adr->get_name().size())) > 0)
+ {
+ // If name, include 'value' instead of payload, and leave of response
+ // details.
+ message = build_VehicleMessage(build_SimpleMessage(adr->get_name(), build_DynamicField(value)));
+ }
+ else
+ {
+ // If no name, send full details of response but still include 'value'
+ // instead of 'payload' if they provided a decoder. The one case you
+ // can't get is the full detailed response with 'value'. We could add
+ // another parameter for that but it's onerous to carry that around.
+ message = build_VehicleMessage(adr, response, value);
+ }
+
+ if(adr->get_callback() != nullptr)
+ {
+ adr->get_callback()(adr, &response, value);
+ }
+
+ return message;
+}
+
+/// @brief Will take the CAN message and pass it to the receive functions that will process
+/// diagnostic handle for each active diagnostic request then depending on the result we will
+/// return pass the diagnostic 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();
+ }
+
+ 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
diff --git a/src/diagnostic/diagnostic-manager.hpp b/src/diagnostic/diagnostic-manager.hpp
index 1db8363..5a4278d 100644
--- a/src/diagnostic/diagnostic-manager.hpp
+++ b/src/diagnostic/diagnostic-manager.hpp
@@ -80,19 +80,23 @@ public:
void checkSupportedPids(const active_diagnostic_request_t& request,
const DiagnosticResponse& response, float parsedPayload);
+ // Subscription parts
bool add_request(DiagnosticRequest* request, const std::string name,
bool waitForMultipleResponses, const DiagnosticResponseDecoder decoder,
const DiagnosticResponseCallback callback);
-
bool add_recurring_request(DiagnosticRequest* request, const char* name,
bool waitForMultipleResponses, const DiagnosticResponseDecoder decoder,
const DiagnosticResponseCallback callback, float frequencyHz);
-
-
- openxc_VehicleMessage relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response) const;
+ // Sendig requests part
bool conflicting(active_diagnostic_request_t* request, active_diagnostic_request_t* candidate) const;
bool clear_to_send(active_diagnostic_request_t* request) const;
static int send_request(sd_event_source *s, uint64_t usec, void *userdata);
+
+ // Decoding part
+ openxc_VehicleMessage relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response) const;
+ openxc_VehicleMessage relay_diagnostic_handle(active_diagnostic_request_t* entry, const can_message_t& cm);
+ openxc_VehicleMessage find_and_decode_adr(const can_message_t& cm);
bool is_diagnostic_response(const can_message_t& cm);
+
};