X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fdiagnostic%2Fdiagnostic-message.cpp;h=6f6155745daa1bc0958b83dc520f43935d85de16;hb=429fa417e5822b33b41d35f7d3d590327c145adf;hp=656a868cf9f4b72908430d1d9dab4571ff944958;hpb=2049aca0927b55f2a256fd60ff686616b73eecb7;p=apps%2Fagl-service-can-low-level.git diff --git a/src/diagnostic/diagnostic-message.cpp b/src/diagnostic/diagnostic-message.cpp index 656a868c..6f615574 100644 --- a/src/diagnostic/diagnostic-message.cpp +++ b/src/diagnostic/diagnostic-message.cpp @@ -14,10 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include -#include "obd2/obd2-signals.hpp" +#include "diagnostic-message.hpp" -#include "utils/signals.hpp" +#include "../configuration.hpp" +#include "../utils/signals.hpp" const char *UNIT_NAMES[10] = { "POURCENT", @@ -32,128 +34,75 @@ const char *UNIT_NAMES[10] = { "NM" }; -obd2_signals_t::obd2_signals_t(uint8_t pid, const char* generic_name, const int min, const int max, enum UNIT unit, int frequency, bool supported) - : pid_{pid}, generic_name_{generic_name}, min_{min}, max_{max}, unit_{unit}, frequency_{frequency}, supported_{supported} +diagnostic_message_t::diagnostic_message_t(uint8_t pid, const std::string generic_name, const int min, + const int max, enum UNIT unit, float frequency, DiagnosticResponseDecoder decoder, + DiagnosticResponseCallback callback, bool supported) + : pid_{pid}, generic_name_{generic_name}, min_{min}, max_{max}, unit_{unit}, + frequency_{frequency}, decoder_{decoder}, callback_{callback}, supported_{supported} +{} + +uint32_t diagnostic_message_t::get_pid() { + return (uint32_t)pid_; } -uint32_t obd2_signals_t::get_pid() +const std::string& diagnostic_message_t::get_generic_name() const { - return (uint32_t)pid_; + return generic_name_; } -/** - * @fn std::vector find_signals(const openxc_DynamicField &key) - * @brief return signals name found searching through CAN_signals and OBD2 pid - * - * @param[in] const openxc_DynamicField : can contain numeric or string value in order to search against - * can signals or obd2 signals name. - * - * @return std::vector Vector of signals name found. - */ -void obd2_signals_t::find_obd2_signals(const openxc_DynamicField &key, std::vector& found_signals) +const std::string diagnostic_message_t::get_name() const { - switch(key.type) - { - case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING: - lookup_signals_by_name(key.string_value, get_obd2_signals(), found_signals); - break; - case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM: - lookup_signals_by_id(key.numeric_value, get_obd2_signals(), found_signals); - break; - default: - ERROR(binder_interface, "find_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only."); - break; - } - DEBUG(binder_interface, "Found %d signal(s)", (int)found_signals.size()); + return active_diagnostic_request_t::get_prefix() + "." + generic_name_; } -bool obd2_signals_t::is_obd2_response(can_message_t can_message) +float diagnostic_message_t::get_frequency() const { - /* - if(can_message.get_id() >= 0x7E8 && can_message.get_id() <= 0x7EF) - { - openxc_VehicleMessage message = {0}; - message.has_type = true; - message.type = openxc_VehicleMessage_Type_DIAGNOSTIC; - message.has_diagnostic_response = true; - message.diagnostic_response = {0}; - message.diagnostic_response.has_bus = true; - message.diagnostic_response.bus = bus->address; - message.diagnostic_response.has_message_id = true; - //7DF should respond with a random message id between 7e8 and 7ef - //7E0 through 7E7 should respond with a id that is 8 higher (7E0->7E8) - if(can_message.get_id() == 0x7DF) - { - message.diagnostic_response.message_id = rand()%(0x7EF-0x7E8 + 1) + 0x7E8; - } - else if(commandRequest->message_id >= 0x7E0 && commandRequest->message_id <= 0x7E7) - { - message.diagnostic_response.message_id = commandRequest->message_id + 8; - } - message.diagnostic_response.has_mode = true; - message.diagnostic_response.mode = commandRequest->mode; - if(commandRequest->has_pid) - { - message.diagnostic_response.has_pid = true; - message.diagnostic_response.pid = commandRequest->pid; - } - message.diagnostic_response.has_value = true; - message.diagnostic_response.value = rand() % 100; - pipeline::publish(&message, &getConfiguration()->pipeline); - } - else //If it's outside the range, the command_request will return false - { - debug("Sent message ID is outside the valid range for emulator (7DF to 7E7)"); - status=false; - } - return false; - */ + return frequency_; } -void obd2_signals_t::add_request(int pid) +DiagnosticResponseDecoder diagnostic_message_t::get_decoder() const +{ + return decoder_; +} +DiagnosticResponseCallback diagnostic_message_t::get_callback() const { - DiagnosticRequest request = { - arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID, - mode: 0x1, has_pid: true, pid_ }; + return callback_; } -/** -* @brief Check if a request is an OBD-II PID request. -* -* @return true if the request is a mode 1 request and it has a 1 byte PID. -*/ -bool obd2_signals_t::is_obd2_request(DiagnosticRequest* request) +bool diagnostic_message_t::get_supported() const { - return request->mode == 0x1 && request->has_pid && request->pid < 0xff; + return supported_; +} + +void diagnostic_message_t::set_supported(bool value) +{ + supported_ = value; } -/** -* @brief Check if requested signal name is an obd2 pid -* -* @return true if name began with obd2 else false. -*/ -bool obd2_signals_t::is_obd2_signal(const char *name) +/// +/// @brief Build a DiagnosticRequest struct to be passed +/// to diagnostic manager instance. +/// +const DiagnosticRequest diagnostic_message_t::build_diagnostic_request() { - if(fnmatch("obd2.*", name, FNM_CASEFOLD) == 0) - return true; - return false; + return {/*arbitration_id: */OBD2_FUNCTIONAL_BROADCAST_ID, + /*mode: */0x1, + /*has_pid: */true, + /*pid: */pid_, + /*pid_length: */0, + /*payload[]: */{0}, + /*payload_length: */0, + /*no_frame_padding: */false, + /*DiagnosticRequestType: */DiagnosticRequestType::DIAGNOSTIC_REQUEST_TYPE_PID }; } -/** -* @brief Decode the payload of an OBD-II PID. -* -* This function matches the type signature for a DiagnosticResponseDecoder, so -* it can be used as the decoder for a DiagnosticRequest. It returns the decoded -* value of the PID, using the standard formulas (see -* http://en.wikipedia.org/wiki/OBD-II_PIDs#Mode_01). -* -* @param[in] DiagnosticResponse response - the received DiagnosticResponse (the data is in response.payload, -* a byte array). This is most often used when the byte order is -* signiticant, i.e. with many OBD-II PID formulas. -* @param[in] float parsed_payload - the entire payload of the response parsed as an int. -*/ -float obd2_signals_t::decode_obd2_response(const DiagnosticResponse* response, float parsedPayload) +/// +/// @brief Check if a request is an OBD-II PID request. +/// +/// @return true if the request is a mode 1 request and it has a 1 byte PID. +/// +bool diagnostic_message_t::is_obd2_request(const DiagnosticRequest* request) { - return diagnostic_decode_obd2_pid(response); -} \ No newline at end of file + return request->mode == 0x1 && request->has_pid && request->pid < 0xff; +}