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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
/*
* Copyright (C) 2015, 2016 "IoT.bzh"
* Author "Romain Forlot" <romain.forlot@iot.bzh>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <mutex>
#include <queue>
#include <thread>
#include <linux/can.h>
#include <condition_variable>
#include "openxc.pb.h"
#include "utils/timer.hpp"
#include "can/can-signals.hpp"
#include "can/can-message.hpp"
#include "obd2/diagnostic-manager.hpp"
#include "low-can-binding.hpp"
// TODO actual max is 32 but dropped to 24 for memory considerations
#define MAX_ACCEPTANCE_FILTERS 24
// TODO this takes up a ton of memory
#define MAX_DYNAMIC_MESSAGE_COUNT 12
#define CAN_ACTIVE_TIMEOUT_S 30
class can_bus_dev_t;
class diagnostic_manager_t;
/**
* @class can_bus_t
* @brief Object used to handle decoding and manage event queue to be pushed.
*
* This object is also used to initialize can_bus_dev_t object after reading
* json conf file describing the CAN devices to use. Thus, those object will read
* on the device the CAN frame and push them into the can_bus_t can_message_q_ queue.
*
* That queue will be later used to be decoded and pushed to subscribers.
*/
class can_bus_t {
private:
int conf_file_; /*!< conf_file_ - configuration file handle used to initialize can_bus_dev_t objects.*/
void can_decode_message();
std::thread th_decoding_; /*!< thread that'll handle decoding a can frame */
bool is_decoding_; /*!< boolean member controling thread while loop*/
void can_event_push();
std::thread th_pushing_; /*!< thread that'll handle pushing decoded can frame to subscribers */
bool is_pushing_; /*!< boolean member controling thread while loop*/
std::condition_variable new_can_message_cv_; /*!< condition_variable use to wait until there is a new CAN message to read*/
std::mutex can_message_mutex_; /*!< mutex protecting the can_message_q_ queue.*/
std::queue <can_message_t> can_message_q_; /*!< queue that'll store can_message_t to decoded */
std::condition_variable new_decoded_can_message_; /*!< condition_variable use to wait until there is a new vehicle message to read from the queue vehicle_message_q_*/
std::mutex decoded_can_message_mutex_; /*!< mutex protecting the vehicle_message_q_ queue.*/
std::queue <openxc_VehicleMessage> vehicle_message_q_; /*!< queue that'll store openxc_VehicleMessage to pushed */
std::map<std::string, std::shared_ptr<can_bus_dev_t>> can_devices_m_; /*!< Can device map containing all can_bus_dev_t objects initialized during init_can_dev function*/
public:
can_bus_t(int conf_file);
int init_can_dev();
std::vector<std::string> read_conf();
void start_threads();
void stop_threads();
can_message_t next_can_message();
void push_new_can_message(const can_message_t& can_msg);
std::mutex& get_can_message_mutex();
std::condition_variable& get_new_can_message_cv();
openxc_VehicleMessage next_vehicle_message();
void push_new_vehicle_message(const openxc_VehicleMessage& v_msg);
std::map<std::string, std::shared_ptr<can_bus_dev_t>> get_can_devices();
};
/**
* @class can_bus_dev_t
*
* @brief Object representing a can device. Handle opening, closing and reading on the
* socket. This is the low level object to be use by can_bus_t.
*/
class can_bus_dev_t {
private:
int32_t id_; /*!< int32_t id_ - an identifier used through binding that refer to that device*/
std::string device_name_; /*!< std::string device_name_ - name of the linux device handling the can bus. Generally vcan0, can0, etc. */
int can_socket_; /*!< socket handler for the can device */
bool is_fdmode_on_; /*!< boolean telling if whether or not the can socket use fdmode. */
struct sockaddr_can txAddress_; /*!< internal member using to bind to the socket */
diagnostic_manager_t diagnostic_manager_; /*!< diagnostic_manager_t diagnostic_manager_ - A diagnostic_manager_t object instance
* that will handle diagnostic obd2 protocol requests and responses.*/
std::thread th_reading_; /*!< Thread handling read the socket can device filling can_message_q_ queue of can_bus_t */
bool is_running_; /*!< boolean telling whether or not reading is running or not */
void can_reader(can_bus_t& can_bus);
public:
can_bus_dev_t(const std::string& dev_name);
int open();
int close();
void start_reading(can_bus_t& can_bus);
void stop_reading();
std::pair<struct canfd_frame&, size_t> read();
int send_can_message(can_message_t& can_msg);
};
/** TODO: implement this function as method into can_bus class
* @fn void pre_initialize(can_bus_dev_t* bus, bool writable, can_bus_dev_t* buses, const int busCount);
* @brief Pre initialize actions made before CAN bus initialization
*
* @param[in] can_bus_dev_t bus - A CanBus struct defining the bus's metadata
* @param[in] bool writable - configure the controller in a writable mode. If false, it will be
* configured as "listen only" and will not allow writes or even CAN ACKs.
* @param[in] buses - An array of all CAN buses.
* @param[in] int busCount - The length of the buses array.
*/
void pre_initialize(can_bus_dev_t* bus, bool writable, can_bus_dev_t* buses, const int busCount);
/** TODO: implement this function as method into can_bus class
* @fn void post_initialize(can_bus_dev_t* bus, bool writable, can_bus_dev_t* buses, const int busCount);
* @brief Post-initialize actions made after CAN bus initialization
*
* @param[in] bus - A CanBus struct defining the bus's metadata
* @param[in] writable - configure the controller in a writable mode. If false, it will be
* configured as "listen only" and will not allow writes or even CAN ACKs.
* @param[in] buses - An array of all CAN buses.
* @param[in] busCount - The length of the buses array.
*/
void post_initialize(can_bus_dev_t* bus, bool writable, can_bus_dev_t* buses, const int busCount);
/** TODO: implement this function as method into can_bus class
* @fn bool isBusActive(can_bus_dev_t* bus);
* @brief Check if the device is connected to an active CAN bus, i.e. it's
* received a message in the recent past.
*
* @return true if a message was received on the CAN bus within
* CAN_ACTIVE_TIMEOUT_S seconds.
*/
bool isBusActive(can_bus_dev_t* bus);
/** TODO: implement this function as method into can_bus class
*
* @fn void logBusStatistics(can_bus_dev_t* buses, const int busCount);
* @brief Log transfer statistics about all active CAN buses to the debug log.
*
* @param[in] buses - an array of active CAN buses.
* @param[in] busCount - the length of the buses array.
*/
void logBusStatistics(can_bus_dev_t* buses, const int busCount);
|
