-
Notifications
You must be signed in to change notification settings - Fork 677
Expand file tree
/
Copy pathbus.py
More file actions
314 lines (237 loc) · 10 KB
/
bus.py
File metadata and controls
314 lines (237 loc) · 10 KB
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
#!/usr/bin/env python
# coding: utf-8
"""
Contains the ABC bus implementation and its documentation.
"""
from __future__ import print_function, absolute_import
from abc import ABCMeta, abstractmethod
import logging
import threading
from time import time
from collections import namedtuple
from .broadcastmanager import ThreadBasedCyclicSendTask
BusState = namedtuple('BusState', 'ACTIVE, PASSIVE, ERROR')
class BusABC(object):
"""The CAN Bus Abstract Base Class that serves as the basis
for all concrete interfaces.
"""
#: a string describing the underlying bus and/or channel
channel_info = 'unknown'
@abstractmethod
def __init__(self, channel, can_filters=None, **config):
"""Construct and open a CAN bus instance of the specified type.
Subclasses should call though this method with all given parameters
as it handles generic tasks like applying filters.
:param channel:
The can interface identifier. Expected type is backend dependent.
:param list can_filters:
See :meth:`~can.BusABC.set_filters` for details.
:param dict config:
Any backend dependent configurations are passed in this dictionary
"""
self.set_filters(can_filters)
def __str__(self):
return self.channel_info
def recv(self, timeout=None):
"""Block waiting for a message from the Bus.
:param float timeout:
seconds to wait for a message or None to wait indefinitely
:rtype: can.Message or None
:return:
None on timeout or a :class:`can.Message` object.
:raises can.CanError:
if an error occurred while reading
"""
start = time()
time_left = timeout
while True:
# try to get a message
msg, already_filtered = self._recv_internal(timeout=time_left)
# return it, if it matches
if msg and (already_filtered or self._matches_filters(msg)):
return msg
# if not, and timeout is None, try indefinitely
elif timeout is None:
continue
# try next one only if there still is time, and with reduced timeout
else:
time_left = timeout - (time() - start)
if time_left > 0:
continue
else:
return None
def _recv_internal(self, timeout):
"""
Read a message from the bus and tell whether it was filtered.
This methods may be called by :meth:`~can.BusABC.recv`
to read a message multiple times if the filters set by
:meth:`~can.BusABC.set_filters` do not match and the call has
not yet timed out.
New implementations should always override this method instead of
:meth:`~can.BusABC.recv`, to be able to take advantage of the
software based filtering provided by :meth:`~can.BusABC.recv`
as a fallback. This method should never be called directly.
.. note::
This method is not an `@abstractmethod` (for now) to allow older
external implementations to continue using their existing
:meth:`~can.BusABC.recv` implementation.
.. note::
The second return value (whether filtering was already done) may change
over time for some interfaces, like for example in the Kvaser interface.
Thus it cannot be simplified to a constant value.
:param float timeout: seconds to wait for a message,
see :meth:`can.BusABC.send`
:rtype: tuple[can.Message, bool] or tuple[None, bool]
:return:
1. a message that was read or None on timeout
2. a bool that is True if message filtering has already
been done and else False
:raises can.CanError:
if an error occurred while reading
:raises NotImplementedError:
if the bus provides it's own :meth:`~can.BusABC.recv`
implementation (legacy implementation)
"""
raise NotImplementedError("Trying to read from a write only bus?")
@abstractmethod
def send(self, msg, timeout=None):
"""Transmit a message to the CAN bus.
Override this method to enable the transmit path.
:param can.Message msg: A message object.
:param float timeout:
If > 0, wait up to this many seconds for message to be ACK:ed or
for transmit queue to be ready depending on driver implementation.
If timeout is exceeded, an exception will be raised.
Might not be supported by all interfaces.
:raises can.CanError:
if the message could not be written.
"""
raise NotImplementedError("Trying to write to a readonly bus?")
def send_periodic(self, msg, period, duration=None):
"""Start sending a message at a given period on this bus.
:param can.Message msg:
Message to transmit
:param float period:
Period in seconds between each message
:param float duration:
The duration to keep sending this message at given rate. If
no duration is provided, the task will continue indefinitely.
:return: A started task instance
:rtype: can.CyclicSendTaskABC
.. note::
Note the duration before the message stops being sent may not
be exactly the same as the duration specified by the user. In
general the message will be sent at the given rate until at
least *duration* seconds.
"""
if not hasattr(self, "_lock"):
# Create a send lock for this bus
self._lock = threading.Lock()
return ThreadBasedCyclicSendTask(self, self._lock, msg, period, duration)
def __iter__(self):
"""Allow iteration on messages as they are received.
>>> for msg in bus:
... print(msg)
:yields:
:class:`can.Message` msg objects.
"""
while True:
msg = self.recv(timeout=1.0)
if msg is not None:
yield msg
@property
def filters(self):
return self._filters
@filters.setter
def filters(self, filters):
self.set_filters(filters)
def set_filters(self, filters=None):
"""Apply filtering to all messages received by this Bus.
All messages that match at least one filter are returned.
If `filters` is `None`, all messages are matched.
If it is a zero size interable, no messages are matched.
Calling without passing any filters will reset the applied
filters to `None`.
:param Iterator[dict] filters:
A iterable of dictionaries each containing a "can_id", a "can_mask",
and an optional "extended" key.
>>> [{"can_id": 0x11, "can_mask": 0x21, "extended": False}]
A filter matches, when ``<received_can_id> & can_mask == can_id & can_mask``.
If ``extended`` is set as well, it only matches messages where
``<received_is_extended> == extended``. Else it matches every messages based
only on the arbitration ID and mask.
"""
self._filters = filters
self._apply_filters(self._filters)
def _apply_filters(self, filters):
"""
Hook for applying the filters to the underlying kernel or
hardware if supported/implemented by the interface.
:param Iterator[dict] filters:
See :meth:`~can.BusABC.set_filters` for details.
"""
pass
def _matches_filters(self, msg):
"""Checks whether the given message matches at least one of the
current filters. See :meth:`~can.BusABC.set_filters` for details
on how the filters work.
This method should not be overridden.
:param can.Message msg:
the message to check if matching
:rtype: bool
:return: whether the given message matches at least one filter
"""
# if no filters are set, all messages are matched
if self._filters is None:
return True
for filter in self._filters:
# check if this filter even applies to the message
if 'extended' in filter and \
filter['extended'] != msg.is_extended_id:
continue
# then check for the mask and id
can_id = filter['can_id']
can_mask = filter['can_mask']
# basically, we compute `msg.arbitration_id & can_mask == can_id & can_mask`
# by using the shorter, but equivalent from below:
if (can_id ^ msg.arbitration_id) & can_mask == 0:
return True
# nothing matched
return False
def flush_tx_buffer(self):
"""Discard every message that may be queued in the output buffer(s).
"""
pass
def shutdown(self):
"""
Called to carry out any interface specific cleanup required
in shutting down a bus.
"""
pass
@property
def state(self):
"""
Return the current state of the hardware
:return: ACTIVE, PASSIVE or ERROR
:rtype: NamedTuple
"""
return BusState.ACTIVE
@state.setter
def state(self, new_state):
"""
Set the new state of the hardware
:param new_state: BusState.ACTIVE, BusState.PASSIVE or BusState.ERROR
"""
raise NotImplementedError("Property is not implemented.")
@staticmethod
def _detect_available_configs():
"""Detect all configurations/channels that this interface could
currently connect with.
This might be quite time consuming.
May not to be implemented by every interface on every platform.
:rtype: Iterator[dict]
:return: an iterable of dicts, each being a configuration suitable
for usage in the interface's bus constructor.
"""
raise NotImplementedError()
__metaclass__ = ABCMeta