}
}
-/// @brief Diagnostic manager isn't initialized at launch but after
-/// CAN bus devices initialization. For the moment, it is only possible
+/// @brief Diagnostic manager is not initialized at launch but after
+/// the initialization of CAN bus devices. 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.
///
// Make sure that socket has been opened.
if(! tx_socket)
- tx_socket.open(
- dm.get_bus_device_name());
+ 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 bcm_msg bcm_msg;
+ struct can_frame cf;
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.count = 0;
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);
+ cf.can_dlc = size;
+
+ ::memset(cf.data, 0, sizeof(cf.data));
+ ::memcpy(cf.data, data, size);
+
+ bcm_msg.frames[0] = cf;
+
+
+ std::shared_ptr<can_message_t> msg = std::make_shared<can_message_t>();
- bcm_msg.frames = cfd;
+ msg->set_bcm_msg(bcm_msg);
- tx_socket << bcm_msg;
+ tx_socket.write_message(msg);
if(tx_socket)
return true;
return false;
}
return nullptr;
}
-
+/*
/// @brief Add and send a new one-time diagnostic request. DON'T USED AT THIS TIME
///
/// A one-time (aka non-recurring) request can existing in parallel with a
if (non_recurring_requests_.size() <= MAX_SIMULTANEOUS_DIAG_REQUESTS)
{
active_diagnostic_request_t* entry = new active_diagnostic_request_t(bus_, request->arbitration_id, name,
- wait_for_multiple_responses, decoder, callback, 0);
+ wait_for_multiple_responses, decoder, callback, 0, false);
entry->set_handle(shims_, request);
char request_string[128] = {0};
}
return entry;
}
-
+*/
/// @brief Validate frequency asked don't get higher than the maximum of a classical
/// CAN bus OBD2 request.
///
/// was too much already running requests, or if the frequency was too high.
active_diagnostic_request_t* diagnostic_manager_t::add_recurring_request(DiagnosticRequest* request, const char* name,
bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder,
- const DiagnosticResponseCallback callback, float frequencyHz)
+ const DiagnosticResponseCallback callback, float frequencyHz, bool permanent)
{
active_diagnostic_request_t* entry = nullptr;
if(recurring_requests_.size() <= MAX_SIMULTANEOUS_DIAG_REQUESTS)
{
entry = new active_diagnostic_request_t(bus_, request->arbitration_id, name,
- wait_for_multiple_responses, decoder, callback, frequencyHz);
+ wait_for_multiple_responses, decoder, callback, frequencyHz, permanent);
recurring_requests_.push_back(entry);
entry->set_handle(shims_, request);
/// @param[in] response - The response to decode from which the Vehicle message will be built and returned
///
/// @return A filled openxc_VehicleMessage or a zeroed struct if there is an error.
-openxc_VehicleMessage diagnostic_manager_t::relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response)
+openxc_VehicleMessage diagnostic_manager_t::relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response, const uint64_t timestamp)
{
openxc_VehicleMessage message = build_VehicleMessage();
float value = (float)diagnostic_payload_to_integer(&response);
+
+ struct utils::signals_found found_signals;
+ found_signals = utils::signals_manager_t::instance().find_signals(build_DynamicField((double) adr->get_pid()));
+
if(adr->get_decoder() != nullptr)
{
value = adr->get_decoder()(&response, value);
// If not success but completed then the pid isn't supported
if(!response.success)
{
- struct utils::signals_found found_signals;
- found_signals = utils::signals_manager_t::instance().find_signals(build_DynamicField(adr->get_name()));
found_signals.diagnostic_messages.front()->set_supported(false);
cleanup_request(adr, true);
AFB_NOTICE("PID not supported or ill formed. Please unsubscribe from it. Error code : %d", response.negative_response_code);
// Reset the completed flag handle to make sure that it will be reprocessed the next time.
adr->get_handle()->success = false;
+
+ // Save value and timestamp of diagnostic message
+ if(!found_signals.diagnostic_messages.empty())
+ {
+ // Then, for each diag_message found
+ for(const auto& diag_mess: found_signals.diagnostic_messages)
+ {
+ // Save value and timestamp for this message
+ diag_mess->set_received(true);
+ diag_mess->set_last_value(value);
+ diag_mess->set_timestamp(timestamp);
+ }
+ }
+
return message;
}
/// @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)
+openxc_VehicleMessage diagnostic_manager_t::relay_diagnostic_handle(active_diagnostic_request_t* entry, std::shared_ptr<message_t> m)
{
- DiagnosticResponse response = diagnostic_receive_can_frame(&shims_, entry->get_handle(), cm.get_id(), cm.get_data(), cm.get_length());
+ DiagnosticResponse response = diagnostic_receive_can_frame(&shims_, entry->get_handle(), m->get_id(), m->get_data(), m->get_length());
if(response.completed && entry->get_handle()->completed)
{
if(entry->get_handle()->success)
- return relay_diagnostic_response(entry, response);
+ return relay_diagnostic_response(entry, response, m->get_timestamp());
}
else if(!response.completed && response.multi_frame)
{
/// @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 diagnostic_manager_t::find_and_decode_adr(std::shared_ptr<message_t> m)
{
openxc_VehicleMessage vehicle_message = build_VehicleMessage();
for ( auto entry : non_recurring_requests_)
{
- vehicle_message = relay_diagnostic_handle(entry, cm);
+ vehicle_message = relay_diagnostic_handle(entry, m);
if (is_valid(vehicle_message))
return vehicle_message;
}
for ( auto entry : recurring_requests_)
{
- vehicle_message = relay_diagnostic_handle(entry, cm);
+ vehicle_message = relay_diagnostic_handle(entry, m);
if (is_valid(vehicle_message))
return vehicle_message;
}
/// @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)
+bool diagnostic_manager_t::is_diagnostic_response(std::shared_ptr<message_t> m)
{
- if (cm.get_id() >= 0x7e8 && cm.get_id() <= 0x7ef)
- return true;
+ if(m->get_msg_format() == message_format_t::STANDARD || m->get_msg_format() == message_format_t::EXTENDED)
+ {
+ if (m->get_id() >= 0x7e8 && m->get_id() <= 0x7ef)
+ return true;
+ }
return false;
}
Code Review / apps / agl-service-can-low-level.git / blobdiff