aboutsummaryrefslogtreecommitdiffstats
path: root/README.md
blob: e0d9c5e0f89ed783a6a7d9fcd400c2ea51793fdd (plain) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

# AFB Helpers library

You should find useful utilities to integrate in your bindings development.

This library is the successor of the old git [afb-helpers-submodule](https://gerrit.automotivelinux.org/gerrit/gitweb?p=apps%2Fapp-afb-helpers-submodule.git;a=summary)
now available as a separated library.

Please refer to the documentation in the `docs` folder for further informations.

## Installation

The afb-helpers library is integrated by default in the AGL SDK since the Guppy
version (>=7) and is also available as a package for the AGL supported linux
distributions.

You could find the SDK build from Yocto which embed the afb-helpers library
here:

* For the [releases](https://download.automotivelinux.org/AGL/release/) >= Guppy
 in the latest machine's deploy directory. (e.g for Guppy in
 `latest/<yourmachine>/deploy/sdk` directory)
* For the [master](https://download.automotivelinux.org/AGL/snapshots/master/)
 development branch, in the latest machine's deploy directory. (e.g in
 `latest/<yourmachine>/deploy/sdk` directory)

To install the native package please refer to [this chapter](../host-configuration/docs/1_Prerequisites.md)
in the AGL documentation to install the AGL repository for your distribution.

Then use your package manager to install the library.

### OpenSuse

```bash
sudo zypper ref
sudo zypper install agl-libafb-helpers-devel
```

### Fedora

```bash
sudo dnf ref
sudo dnf install agl-libafb-helpers-devel
```

### Ubuntu/Debian

```bash
sudo apt-get update
sudo apt-get install agl-libafb-helpers-dev
```

## (Optionnal) Remove the git submodule version

If you already use the afb-helpers component but using the submodule version
then you have to get rid of it to be sure to link and use the library version.
To do so, you have to do the following:

* Deinitialize the submodule using `git`

```bash
# This example assumes that the git submodule is named app-afb-helpers-submodule
# and is located at your root project repository.
git submodule deinit app-afb-helpers-submodule
```

* Remove the submodule relatives lines from the `.gitmodules` file

```bash
vim .gitmodules
```

* Remove the `afb-helpers` target link from any CMake target you specified.
 Those lines look like:

```bash
TARGET_LINK_LIBRARIES(${TARGET_NAME}
    afb-helpers # REMOVE THIS LINE
    ${link_libraries}
    )
```

## Add the libafb-helpers as a static library to your binding

In your `config.cmake` file, add a dependency to the afb-helpers library, i.e:

```cmake
set(PKG_REQUIRED_LIST
	json-c
	afb-daemon
	afb-helpers --> this is the afb-helpers library dependency name.
)
```

Or you can also use the [FIND_PACKAGE](https://cmake.org/cmake/help/v3.6/command/find_package.html?highlight=find_package)
CMake command to add it if you don't use the [cmake-apps-module](../cmakeafbtemplates/0_Abstract.html)
payload into meaningful data. /// /// @param[in] 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] parsed_payload - the entire payload of the response parsed as an int. /// /// @return float value after decoding. /// typedef float (*DiagnosticResponseDecoder)(const DiagnosticResponse* response, float parsed_payload); /// @brief: The signature for an optional function to handle a new diagnostic /// response. /// /// @param[in] request - The original diagnostic request. /// @param[in] response - The response object that was just received. /// @param[in] parsed_payload - The payload of the response, parsed as a float. /// typedef void (*DiagnosticResponseCallback)(const active_diagnostic_request_t* request, const DiagnosticResponse* response, float parsed_payload); /// /// @brief An active diagnostic request, either recurring or one-time. /// /// Will host a diagnostic_message_t class members to describe an on going /// diagnostic request on the CAN bus. Diagnostic message will be converted to /// a DiagnosticRequest using ad-hoc method build_diagnostic_request from diagnostic message. /// Then missing member, that can not be hosted into a DiagnosticRequest struct, will be passed /// as argument when adding the request to (non)-recurrent vector. Argument will be used to instanciate /// an active_diagnostic_request_t object before sending it. /// class active_diagnostic_request_t { private: std::string bus_; ///< bus_ - The CAN bus this request should be made on, or is currently in flight-on uint32_t id_; ///< id_ - The arbitration ID (aka message ID) for the request. DiagnosticRequestHandle* handle_; ///< handle_ - A handle for the request to keep track of it between ///< sending the frames of the request and receiving all frames of the response. std::string name_; ///< name_ - Human readable name, to be used when publishing received responses. static std::string prefix_; ///< prefix_ - It has to reflect the JSON object which it comes from. It makes easier sorting ///< incoming CAN messages. DiagnosticResponseDecoder decoder_; ///< decoder_ - An optional DiagnosticResponseDecoder to parse the payload of responses ///< to this request. If the decoder is NULL, the output will include the raw payload ///< instead of a parsed value. DiagnosticResponseCallback callback_; ///< callback_ - An optional DiagnosticResponseCallback to be notified whenever a ///< response is received for this request. bool recurring_; ///< bool recurring_ - If true, this is a recurring request and it will remain as active until explicitly cancelled. ///< The frequencyClock attribute controls how often a recurring request is made. bool permanent_; ///< bool permanent_ - If true, this a permanent recurring request and will remain as active indefinitely (can't be cancelled). bool wait_for_multiple_responses_; ///< wait_for_multiple_responses_ - False by default, when any response is received for a request ///< it will be removed from the active list. If true, the request will remain active until the timeout ///< clock expires, to allow it to receive multiple response (e.g. to a functional broadcast request). frequency_clock_t frequency_clock_; ///< frequency_clock_ - A frequency_clock_t object to control the send rate for a ///< recurring request. If the request is not reecurring, this attribute is not used. frequency_clock_t timeout_clock_; ///< timeout_clock_ - A frequency_clock_t object to monitor how long it's been since ///< this request was sent. utils::socketcan_bcm_t socket_; ///< socket_ - A BCM socket setup to send cyclic message to CAN ID 7DF. public: bool operator==(const active_diagnostic_request_t& b); active_diagnostic_request_t& operator=(const active_diagnostic_request_t& adr); active_diagnostic_request_t(); active_diagnostic_request_t(active_diagnostic_request_t&&) = default; 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, bool permanent); ~active_diagnostic_request_t(); uint32_t get_id() const; DiagnosticRequestHandle* get_handle(); uint16_t get_pid() const; const std::string get_name() const; static std::string& get_prefix(); DiagnosticResponseDecoder& get_decoder(); DiagnosticResponseCallback& get_callback(); bool get_recurring() const; bool get_permanent() const; frequency_clock_t& get_frequency_clock(); frequency_clock_t& get_timeout_clock(); utils::socketcan_bcm_t& get_socket(); void set_handle(DiagnosticShims& shims, DiagnosticRequest* request); static bool is_diagnostic_signal(const std::string& name); bool response_received() const; };