aboutsummaryrefslogtreecommitdiffstats
path: root/can-utils.h
blob: 20e37fc3f186231affce2ae7d5eda72c2c36b48c (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
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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
/*
 * 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 <string>
#include "timer.h"
#include "openxc.pb.h"

// 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_MESSAGE_SIZE 8

#define CAN_ACTIVE_TIMEOUT_S 30

#define QUEUE_DECLARE(type, max_length) \
static const int queue_##type##_max_length = max_length; \
static const int queue_##type##_max_internal_length = max_length + 1; \
typedef struct queue_##type##_s { \
    int head; \
    int tail; \
    type elements[max_length + 1]; \
} queue_##type; \
\
bool queue_##type##_push(queue_##type* queue, type value); \
\
type queue_##type##_pop(queue_##type* queue); \
\
type queue_##type##_peek(queue_##type* queue); \
void queue_##type##_init(queue_##type* queue); \
int queue_##type##_length(queue_##type* queue); \
int queue_##type##_available(queue_##type* queue); \
bool queue_##type##_full(queue_##type* queue); \
bool queue_##type##_empty(queue_##type* queue); \
void queue_##type##_snapshot(queue_##type* queue, type* snapshot, int max);

/* Public: The type signature for a CAN signal decoder.
 *
 * A SignalDecoder transforms a raw floating point CAN signal into a number,
 * string or boolean.
 *
 * signal - The CAN signal that we are decoding.
 * signals - The list of all signals.
 * signalCount - The length of the signals array.
 * value - The CAN signal parsed from the message as a raw floating point
 *      value.
 * send - An output parameter. If the decoding failed or the CAN signal should
 *      not send for some other reason, this should be flipped to false.
 *
 * Returns a decoded value in an openxc_DynamicField struct.
 */
typedef openxc_DynamicField (*SignalDecoder)(struct CanSignal* signal,
        CanSignal* signals, int signalCount, float value, bool* send);

/* Public: The type signature for a CAN signal encoder.
 *
 * A SignalEncoder transforms a number, string or boolean into a raw floating
 * point value that fits in the CAN signal.
 *
 * signal - The CAN signal to encode. 
 * value - The dynamic field to encode.
 * send - An output parameter. If the encoding failed or the CAN signal should
 * not be encoded for some other reason, this will be flipped to false.
 */
typedef uint64_t (*SignalEncoder)(struct CanSignal* signal,
        openxc_DynamicField* value, bool* send);

/* CanBus represent a can device definition gotten from configuraiton file */
class CanBus {
	private:
		/* Got from conf file */
		std::string deviceName;

		int socket;
		bool is_fdmode_on;
		struct sockaddr_can txAddress;

        std::thread th_reading;
        std::thread th_decoding;
        std::thread th_pushing;

	public:
		int open();
		int close();

        void start_threads();
};

/* Public: The ID format for a CAN message.
 *
 * STANDARD - standard 11-bit CAN arbitration ID.
 * EXTENDED - an extended frame, with a 29-bit arbitration ID.
 */
enum CanMessageFormat {
    STANDARD,
    EXTENDED,
};
typedef enum CanMessageFormat CanMessageFormat;

/* Public: A state encoded (SED) signal's mapping from numerical values to
 * OpenXC state names.
 *
 * value - The integer value of the state on the CAN bus.
 * name  - The corresponding string name for the state in OpenXC.
struct CanSignalState {
    const int value;
    const char* name;
};
typedef struct CanSignalState CanSignalState;
 */
 class CanSignalState {
     private:
        const int value;
        const char *name;
 }

/* Public: A CAN signal to decode from the bus and output over USB.
 *
 * message     - The message this signal is a part of.
 * genericName - The name of the signal to be output over USB.
 * bitPosition - The starting bit of the signal in its CAN message (assuming
 *               non-inverted bit numbering, i.e. the most significant bit of
 *               each byte is 0)
 * bitSize     - The width of the bit field in the CAN message.
 * factor      - The final value will be multiplied by this factor. Use 1 if you
 *               don't need a factor.
 * offset      - The final value will be added to this offset. Use 0 if you
 *               don't need an offset.
 * minValue    - The minimum value for the processed signal.
 * maxValue    - The maximum value for the processed signal.
 * frequencyClock - A FrequencyClock struct to control the maximum frequency to
 *              process and send this signal. To process every value, set the
 *              clock's frequency to 0.
 * sendSame    - If true, will re-send even if the value hasn't changed.
 * forceSendChanged - If true, regardless of the frequency, it will send the
 *              value if it has changed.
 * states      - An array of CanSignalState describing the mapping
 *               between numerical and string values for valid states.
 * stateCount  - The length of the states array.
 * writable    - True if the signal is allowed to be written from the USB host
 *               back to CAN. Defaults to false.
 * decoder     - An optional function to decode a signal from the bus to a human
 *      readable value. If NULL, the default numerical decoder is used.
 * encoder     - An optional function to encode a signal value to be written to
 *                CAN into a byte array. If NULL, the default numerical encoder
 *                is used.
 * received    - True if this signal has ever been received.
 * lastValue   - The last received value of the signal. If 'received' is false,
 *      this value is undefined.
struct CanSignal {
    struct CanMessageDefinition* message;
    const char* genericName;
    uint8_t bitPosition;
    uint8_t bitSize;
    float factor;
    float offset;
    float minValue;
    float maxValue;
    FrequencyClock frequencyClock;
    bool sendSame;
    bool forceSendChanged;
    const CanSignalState* states;
    uint8_t stateCount;
    bool writable;
    SignalDecoder decoder;
    SignalEncoder encoder;
    bool received;
    float lastValue;
};
typedef struct CanSignal CanSignal;
 */

class CanSignal {
    private:
        const char *generic_name;
        uint8_t bit_position;
        uint8_t bit_size;
        float factor;
        float offset;
        float min_value;
        float max_value;
        FrequencyClock clock;
        bool send_same;
        bool force_send_changed;
        const CanSignalState *states;
        uint8_t state_count;
        bool writable;
        SignalDecoder decoder;
        SignalEncoder encoder;
        bool received;
        float last_value;
}

/* Public: The definition of a CAN message. This includes a lot of metadata, so
 * to save memory this struct should not be used for storing incoming and
 * outgoing CAN messages.
 *
 * bus - A pointer to the bus this message is on.
 * id - The ID of the message.
 * format - the format of the message's ID.
 * clock - an optional frequency clock to control the output of this
 *      message, if sent raw, or simply to mark the max frequency for custom
 *      handlers to retrieve.
 * forceSendChanged - If true, regardless of the frequency, it will send CAN
 *      message if it has changed when using raw passthrough.
 * lastValue - The last received value of the message. Defaults to undefined.
 *      This is required for the forceSendChanged functionality, as the stack
 *      needs to compare an incoming CAN message with the previous frame.
struct CanMessageDefinition {
    struct CanBus* bus;
    uint32_t id;
    CanMessageFormat format;
    FrequencyClock frequencyClock;
    bool forceSendChanged;
    uint8_t lastValue[CAN_MESSAGE_SIZE];
};
typedef struct CanMessageDefinition CanMessageDefinition;
 */
 class CanMessageDefinition {
    private:
        CanBus *bus
        uint32_t id;
        CanMessageFormat format;
        FrequencyClock clock;
        bool force_send_changed;
        uint8_t last_value[CAN_MESSAGE_SIZE];
 }

/* A compact representation of a single CAN message, meant to be used in in/out
 * buffers.
 *
 * id - The ID of the message.
 * format - the format of the message's ID.
 * data  - The message's data field.
 * length - the length of the data array (max 8).
struct CanMessage {
    uint32_t id;
    CanMessageFormat format;
    uint8_t data[CAN_MESSAGE_SIZE];
    uint8_t length;
};
typedef struct CanMessage CanMessage;
*/
class CanMessage {
    private:
        uint32_t id;
        CanMessageFormat format;
        uint8_t data[CAN_MESSAGE_SIZE];
        uint8_t length;
}

QUEUE_DECLARE(CanMessage, 8);

/* Private: An entry in the list of acceptance filters for each CanBus.
 *
 * This struct is meant to be used with a LIST type from <sys/queue.h>.
 *
 * filter - the value for the CAN acceptance filter.
 * activeUserCount - The number of active consumers of this filter's messages.
 *      When 0, this filter can be removed.
 * format - the format of the ID for the filter.
struct AcceptanceFilterListEntry {
    uint32_t filter;
    uint8_t activeUserCount;
    CanMessageFormat format;
    LIST_ENTRY(AcceptanceFilterListEntry) entries;
};
 */

/* Private: A type of list containing CAN acceptance filters.
LIST_HEAD(AcceptanceFilterList, AcceptanceFilterListEntry);

struct CanMessageDefinitionListEntry {
    CanMessageDefinition definition;
    LIST_ENTRY(CanMessageDefinitionListEntry) entries;
};
LIST_HEAD(CanMessageDefinitionList, CanMessageDefinitionListEntry);
 */

/** Public: A parent wrapper for a particular set of CAN messages and associated
 *  CAN buses(e.g. a vehicle or program).
 *
 *  index - A numerical ID for the message set, ideally the index in an array
 *      for fast lookup
 *  name - The name of the message set.
 *  busCount - The number of CAN buses defined for this message set.
 *  messageCount - The number of CAN messages (across all buses) defined for
 *      this message set.
 *  signalCount - The number of CAN signals (across all messages) defined for
 *      this message set.
 *  commandCount - The number of CanCommmands defined for this message set.
typedef struct {
    uint8_t index;
    const char* name;
    uint8_t busCount;
    unsigned short messageCount;
    unsigned short signalCount;
    unsigned short commandCount;
} CanMessageSet;
 */
class CanMessageSet {
    private:
        uint8_t index;
        const char * name;
        uint8_t busCount;
        unsigned short messageCount;
        unsigned short signalCount;
        unsigned short commandCount;
}

/* Public: The type signature for a function to handle a custom OpenXC command.
 *
 * name - the name of the received command.
 * value - the value of the received command, in a DynamicField. The actual type
 *      may be a number, string or bool.
 * event - an optional event from the received command, in a DynamicField. The
 *      actual type may be a number, string or bool.
 * signals - The list of all signals.
 * signalCount - The length of the signals array.
 */
typedef void (*CommandHandler)(const char* name, openxc_DynamicField* value,
        openxc_DynamicField* event, CanSignal* signals, int signalCount);

/* Public: The structure to represent a supported custom OpenXC command.
 *
 * For completely customized CAN commands without a 1-1 mapping between an
 * OpenXC message from the host and a CAN signal, you can define the name of the
 * command and a custom function to handle it in the VI. An example is
 * the "turn_signal_status" command in OpenXC, which has a value of "left" or
 * "right". The vehicle may have separate CAN signals for the left and right
 * turn signals, so you will need to implement a custom command handler to send
 * the correct signals.
 *
 * Command handlers are also useful if you want to trigger multiple CAN messages
 * or signals from a signal OpenXC message.
 *
 * genericName - The name of the command.
 * handler - An function to process the received command's data and perform some
 *      action.
typedef struct {
    const char* genericName;
    CommandHandler handler;
} CanCommand;
 */

class CanCommand {
    private:
        const char* genericName;
        CommandHandler handler;
}

/* Pre initialize actions made before CAN bus initialization
 *
 * bus - A CanBus struct defining the bus's metadata
 * 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.
 * buses - An array of all CAN buses.
 * busCount - The length of the buses array.
 */
void pre_initialize(CanBus* bus, bool writable, CanBus* buses, const int busCount);

/* Post-initialize actions made after CAN bus initialization and before the
 * event loop connection.
 *
 * bus - A CanBus struct defining the bus's metadata
 * 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.
 * buses - An array of all CAN buses.
 * busCount - The length of the buses array.
 */
void post_initialize(CanBus* bus, bool writable, CanBus* buses, const int busCount);

/* Public: Check if the device is connected to an active CAN bus, i.e. it's
 * received a message in the recent past.
 *
 * Returns true if a message was received on the CAN bus within
 * CAN_ACTIVE_TIMEOUT_S seconds.
 */
bool isBusActive(CanBus* bus);

/* Public: Log transfer statistics about all active CAN buses to the debug log.
 *
 * buses - an array of active CAN buses.
 * busCount - the length of the buses array.
 */
void logBusStatistics(CanBus* buses, const int busCount);