From 32e25cbca210a359b09768537b6f443fe90a3070 Mon Sep 17 00:00:00 2001 From: Romain Forlot Date: Tue, 20 Jun 2017 10:24:05 +0000 Subject: Separation Generator to a dedicated repo Change-Id: Id94831651c3266861435272a6e36c7884bef2c45 Signed-off-by: Romain Forlot --- libs/uds-c/README.mkd | 196 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 196 insertions(+) create mode 100644 libs/uds-c/README.mkd (limited to 'libs/uds-c/README.mkd') diff --git a/libs/uds-c/README.mkd b/libs/uds-c/README.mkd new file mode 100644 index 0000000..aa0d7fd --- /dev/null +++ b/libs/uds-c/README.mkd @@ -0,0 +1,196 @@ +Unified Diagnostic Services (UDS) Support Library in C +====================================================== + +This is a platform agnostic C library that implements the Unified Diagnostics +Services protocol for automotive electronics. UDS is documented in ISO 14229 and +is the underpinning for the more well-known On-board Diagnostics (OBD) standard. +The library currently supports UDS running over CAN (ISO 15765-4), which uses +the ISO-TP (ISO 15765-2) protocol for message framing. + +This library doesn't assume anything about the source of your diagnostic message +requests or underlying interface to the CAN bus. It uses dependency injection to +give you complete control. + +## Usage + +First, create some shim functions to let this library use your lower level +system: + + // required, this must send a single CAN message with the given arbitration + // ID (i.e. the CAN message ID) and data. The size will never be more than 8 + // bytes. + bool send_can(const uint32_t arbitration_id, const uint8_t* data, + const uint8_t size) { + ... + } + + // optional, provide to receive debugging log messages + void debug(const char* format, ...) { + ... + } + + + // not used in the current version + void set_timer(uint16_t time_ms, void (*callback)) { + ... + } + +With your shims in place, create a `DiagnosticShims` object to pass them around: + + DiagnosticShims shims = diagnostic_init_shims(debug, send_can, set_timer); + +With your shims in hand, send a simple PID request to the standard broadcast +address, `0x7df` (we use the constant `OBD2_FUNCTIONAL_BROADCAST_ID` here): + + // Optional: This is your callback that will be called the response to your + // diagnostic request is received. + void response_received_handler(const DiagnosticResponse* response) { + // You received a response! Do something with it. + } + + DiagnosticRequestHandle handle = diagnostic_request_pid(&shims, + DIAGNOSTIC_STANDARD_PID, // this is a standard PID request, not an extended or enhanced one + OBD2_FUNCTIONAL_BROADCAST_ID, // the request is going out to the broadcast arbitration ID + 0x2, // we want PID 0x2 + response_received_handler); // our callback (optional, use NULL if you don't have one) + + if(handle.completed) { + if(!handle.success) { + // something happened and it already failed - possibly we aren't + // able to send CAN messages + return; + } else { + // this should never occur right away - you need to receive a fresh + // CAN message first + } + } else { + while(true) { + // Continue to read from CAN, passing off each message to the handle. + // This will return a 'completed' DiagnosticResponse when the when + // the request is completely sent and the response is received + // (which may take more than 1 CAN frames) + DiagnosticResponse response = diagnostic_receive_can_frame(&shims, + &handle, can_message_id, can_data, sizeof(can_data)); + + if(response.completed && handle.completed) { + if(handle.success) { + if(response.success) { + // The request was sent successfully, the response was + // received successfully, and it was a positive response - we + // got back some data! + } else { + // The request was sent successfully, the response was + // received successfully, BUT it was a negative response + // from the other node. + printf("This is the error code: %d", response.negative_response_code); + } + } else { + // Some other fatal error ocurred - we weren't able to send + // the request or receive the response. The CAN connection + // may be down. + } + } + } + } + +### Requests for other modes + +If you want to do more besides PID requests on mode 0x1 and 0x22, there's a +lower level API you can use. Here's how to make a mode 3 request to get DTCs. + + DiagnosticRequest request = { + arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID, + mode: OBD2_MODE_EMISSIONS_DTC_REQUEST + }; + DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request, NULL); + + if(handle.completed) { + if(!handle.success) { + // something happened and it already failed - possibly we aren't + // able to send CAN messages + return; + } else { + // this should never occur right away - you need to receive a fresh + // CAN message first + } + } else { + while(true) { + // Continue to read from CAN, passing off each message to the handle. + // This will return a 'completed' DiagnosticResponse when the when + // the request is completely sent and the response is received + // (which may take more than 1 CAN frames) + DiagnosticResponse response = diagnostic_receive_can_frame(&shims, + &handle, can_message_id, can_data, sizeof(can_data)); + + if(response.completed && handle.completed) { + if(handle.success) { + if(response.success) { + // The request was sent successfully, the response was + // received successfully, and it was a positive response - we + // got back some data! + printf("The DTCs are: "); + for(int i = 0; i < response.payload_length; i++) { + printf("0x%x ", response.payload[i]); + } + } else { + // The request was sent successfully, the response was + // received successfully, BUT it was a negative response + // from the other node. + printf("This is the error code: %d", response.negative_response_code); + } + } else { + // Some other fatal error ocurred - we weren't able to send + // the request or receive the response. The CAN connection + // may be down. + } + } + } + } + +## Dependencies + +This library requires 2 dependencies: + +* [isotp-c](https://github.com/openxc/isotp-c) +* [bitfield-c](https://github.com/openxc/bitfield-c) + +## Testing + +The library includes a test suite that uses the `check` C unit test library. + + $ make test + +You can also see the test coverage if you have `lcov` installed and the +`BROWSER` environment variable set to your choice of web browsers: + + $ BROWSER=google-chrome-stable make coverage + +## OBD-II Basics + +TODO diagram out a request, response and error response + +* store the request arb id, mode, pid, and payload locally +* send a can message +* get all new can messages passed to it +* Check the incoming can message to see if it matches one of the standard ECU + response IDs, or our arb ID + 0x8 +* if it matches, parse the diagnostic response and call the callback + + +## Future Notes + +you're going to request a few PIDs over and over again at some frequency +you're going to request DTCs once and read the response +you're going to clear DTCs once + +we need another layer on top of that to handle the repeated requests. + +## Authors + +Chris Peplin cpeplin@ford.com + +## License + +Copyright (c) 2013 Ford Motor Company + +Licensed under the BSD license. -- cgit 1.2.3-korg