def main ():
bus0 = can.interface.Bus(channel='can0', bustype='socketcan_native')
bus1 = can.interface.Bus(channel='can1', bustype='socketcan_native')
manager = DataManager()
listener = MyListener(manager)
listener2 = MyListener2(manager)
lcd_manager = LCDManager(bus0)
ac_lcd_manager = ACLCDManager(bus0, manager)
notifier = can.Notifier(bus0, [listener])
notifier2 = can.Notifier(bus1, [listener2])
counter = 0
try:
while True:
lcd_manager.message = manager.getMessage()
lcd_manager.show()
ac_lcd_manager.show()
time.sleep(0.1)
except KeyboardInterrupt:
bus0.shutdown()
notifier.stop()
notifier2.stop()
def __init__(self):
self.cnt = 0
## close can0
os.system('sudo ifconfig can0 down')
## set bitrate of can0
os.system('sudo ip link set can0 type can bitrate 500000')
## open can0
os.system('sudo ifconfig can0 up')
# os.system('sudo /sbin/ip link set can0 up type can bitrate 250000')
## show details can0 for debug.
# os.system('sudo ip -details link show can0')
if 0:
## set up CAN Bus of J1939
self.bus = j1939.Bus(channel='can0', bustype='socketcan_native')
# set up Notifier
self.notifier = can.Notifier(self.bus, [self.msg_handler])
else:
# set up can interface.
self.can0 = can.interface.Bus(channel = 'can0', bustype = 'socketcan_ctypes')# socketcan_native socketcan_ctypes
## set up Notifier
self.notifier = can.Notifier(self.can0, [self.msg_handler])
self.can_parser = CANParser()
self.lines = 0
def main(args):
"""Send some messages to itself and apply filtering."""
with can.Bus(bustype='socketcan', channel='can0', bitrate=500000, receive_own_messages=False) as bus:
can_filters = [{"can_id": 0x14ff0331, "can_mask": 0xF, "extended": True}]
bus.set_filters(can_filters)
# set to read-only, only supported on some interfaces
#bus.state = BusState.PASSIVE
# print all incoming messages, wich includes the ones sent,
# since we set receive_own_messages to True
# assign to some variable so it does not garbage collected
#notifier = can.Notifier(bus, [can.Printer()]) # pylint: disable=unused-variable
notifier = can.Notifier(bus, [can.Logger("logfile.asc"), can.Printer()]) #can.Logger("recorded.log")
#bus.send(can.Message(arbitration_id=1, is_extended_id=True))
#bus.send(can.Message(arbitration_id=2, is_extended_id=True))
#bus.send(can.Message(arbitration_id=1, is_extended_id=False))
try:
while True:
#msg = bus.recv(1)
#if msg is not None:
# print(msg)
time.sleep(1.0)
except KeyboardInterrupt:
logging.debug(f"KeyboardInterrupt")
except Exception as e:
logging.debug(f"other exception")
async def main():
can0 = can.Bus('vcan0', bustype='virtual', receive_own_messages=True)
reader = can.AsyncBufferedReader()
logger = can.Logger('logfile.asc')
listeners = [
print_message, # Callback function
reader, # AsyncBufferedReader() listener
logger # Regular Listener object
]
# Create Notifier with an explicit loop to use for scheduling of callbacks
loop = asyncio.get_event_loop()
notifier = can.Notifier(can0, listeners, loop=loop)
# Start sending first message
can0.send(can.Message(arbitration_id=0))
print('Bouncing 10 messages...')
for _ in range(10):
# Wait for next message from AsyncBufferedReader
msg = await reader.get_message()
# Delay response
await asyncio.sleep(0.5)
msg.arbitration_id += 1
can0.send(msg)
# Wait for last message to arrive
await reader.get_message()
print('Done!')
# Clean-up
notifier.stop()
can0.shutdown()
def update_can():
bus = can.Bus(interface='socketcan',
channel='can0',
receive_own_messages=True)
# can.Notifier(bus, [can.Logger("recorded.log"), can.Printer()])
can.Notifier(bus)
print("CAN Thread started")
def connect(self, *args, **kwargs):
"""Connect to CAN bus using python-can.
Arguments are passed directly to :class:`can.BusABC`. Typically these
may include:
:param channel:
Backend specific channel for the CAN interface.
:param str bustype:
Name of the interface, e.g. 'kvaser', 'socketcan', 'pcan'...
:param int bitrate:
Bitrate in bit/s.
:raises can.CanError:
When connection fails.
"""
# If bitrate has not been specified, try to find one node where bitrate
# has been specified
if "bitrate" not in kwargs:
for node in self.nodes:
if node.object_dictionary.bitrate:
kwargs["bitrate"] = node.object_dictionary.bitrate
break
self.bus = can.interface.Bus(*args, **kwargs)
logger.info("Connected to '%s'", self.bus.channel_info)
self.notifier = can.Notifier(self.bus, self.listeners, 1)
def __init__(self, ui):
self.ui = ui
self.bus = can.interface.Bus('infotainment', bustype='virtual')
self.listener = can.BufferedReader()
self.notifier = can.Notifier(self.bus, [self.listener])
self.caniterator = CANIterator(self, self.listener)
self.caniterator.start()
def ReEstablishConnection(self):
"""Tries to ensure the canX socket is on-line"""
print(
"attempting to establish the connection to the CAN interface: {0}".
format(self.channel))
if self.isVirtualCAN == False:
# brings the socket down
osCmdDown = 'sudo ifconfig {0} down'.format(self.channel)
print(osCmdDown)
os.system(osCmdDown)
# Make sure the interface is running, brings socket back up
osCmdUp = 'sudo /sbin/ip link set {0} up type can bitrate {1}'.format(
self.channel, self.bitrate)
print(osCmdUp)
os.system(osCmdUp)
time.sleep(1)
# Initialize the CAN interface object
self.bus = can.interface.Bus(channel=self.channel,
bustype='socketcan_native')
self.a_listener = CANListener()
self.notifier = can.Notifier(self.bus, [self.a_listener])
def main():
global device_id
global encoder_value_send_task
if len(sys.argv) != 2:
usage()
sys.exit(1)
device_id = int(sys.argv[1])
if device_id < 0 or device_id >= 63:
usage()
sys.exit(1)
can.rc['interface'] = 'socketcan_ctypes'
can.rc['channel'] = 'vcan0'
bus = Bus()
notifier = can.Notifier(bus, [Listener()])
status_3_msg = can.Message(arbitration_id=(talon_srx.STATUS_3 | device_id),
extended_id=True,
data=make_status_3_msg())
status_3_task = can.send_periodic(can.rc['channel'], status_3_msg, 0.1)
while True:
status_3_msg.data = make_status_3_msg()
status_3_task.modify_data(status_3_msg)
time.sleep(0.05)
notifier.stop()
def read_msg_listener(can_interface):
"""
basic listener
"""
bus = can.interface.Bus(channel=can_interface, bustype=bustype)
listener = can.Listener()
"""
msg = bus.recv()
if msg is None:
print("Timeout accured, no message is recieved.")
else:
print(msg)
"""
reader = can.BufferedReader() # reader is a Listener
notifier = can.Notifier(bus, [reader])
#time.sleep(10)
msg = None
while msg is None:
msg = reader.get_message() # as a parameter can be Timeout ->
# now either call
print(msg)
listener(msg)
# or
listener.on_message_received(msg)
print(msg)
time.sleep(10)
listener.stop()
def __init__(self, callback, filter, bus):
self.__bus = bus
listener = can.Listener()
listener.on_message_received = callback
self.__notifier = can.Notifier(self.__bus, [listener], 0)
self.__listeners = [listener]
self.addFilter(filter)
def __init__(self, bus):
super().__init__('radar')
self.tracks_pub = self.create_publisher(RadarTracks, 'radar_tracks')
#self.can_pub = self.create_publisher(CanMessage, 'can_send')
self.adas_db = cantools.db.load_file(os.path.join(opendbc.DBC_PATH, 'toyota_prius_2017_adas.dbc'))
#self.can_sub = self.create_subscription(CanMessage, 'can_recv', self.on_can_message)
self.radar_pub = self.create_publisher(RadarTracks, 'radar_tracks')
self.can_bus = can.interface.Bus(bustype='socketcan', channel=bus, extended=False)
self.can_notifier = can.Notifier(self.can_bus, [self], timeout=0.0001)
# This triggers self.power_on_radar() @ 100hz.
# Based on OpenPilot, this is the base update rate required for delivering the CAN messages defined in STATIC_MSGS
self.rate = 1.0 / 100.0
#self.power_on_timer = self.create_timer(self.rate, self.power_on_radar)
self.radar_is_on = False
self.frame = 0
self.start_time = time.clock_gettime(time.CLOCK_MONOTONIC_RAW)
self.ticks = 0
self.current_radar_counter = 0
self.current_track_ids = {}
self.current_radar_accels = []
self.cache_radar_tracks = {}
# only need to create these once, they are not recreated in the message loop
for i in range(0, self.RADAR_TRACK_ID_RANGE):
track = RadarTrack()
track.track_id = i
track.valid_count = 0
track.valid = False
self.cache_radar_tracks[i] = track
self.reset_tracks()
def __init__(self, stdscr, args):
self._stdscr = stdscr
self._dbase = database.load_file(args.database,
encoding=args.encoding,
frame_id_mask=args.frame_id_mask,
strict=not args.no_strict)
self._single_line = args.single_line
self._filtered_sorted_message_names = []
self._filter = ''
self._compiled_filter = None
self._formatted_messages = {}
self._playing = True
self._modified = True
self._show_filter = False
self._queue = Queue()
self._nrows, self._ncols = stdscr.getmaxyx()
self._received = 0
self._discarded = 0
self._basetime = None
stdscr.nodelay(True)
curses.use_default_colors()
curses.curs_set(False)
curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_GREEN)
curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_CYAN)
bus = self.create_bus(args)
self._notifier = can.Notifier(bus, [self])
def testAddListenerToNotifier(self):
a_listener = can.Printer()
notifier = can.Notifier(self.bus, [], 0.1)
notifier.stop()
self.assertNotIn(a_listener, notifier.listeners)
notifier.add_listener(a_listener)
self.assertIn(a_listener, notifier.listeners)
def testRemoveListenerFromNotifier(self):
a_listener = can.Printer()
notifier = can.Notifier(self.bus, [a_listener], 0.1)
notifier.stop()
self.assertIn(a_listener, notifier.listeners)
notifier.remove_listener(a_listener)
self.assertNotIn(a_listener, notifier.listeners)
async def test_some_asyncio_code(self, can0, event_loop):
reader = can.AsyncBufferedReader()
notifier = can.Notifier(can0, [reader], loop=event_loop)
can0.send(can.Message(arbitration_id=1))
msg = await reader.get_message()
assert msg.arbitration_id == 1
notifier.stop()
def connect(self, *args, **kwargs):
"""Connect to CAN bus using python-can.
Arguments are passed directly to :class:`can.BusABC`. Typically these
may include:
:param channel:
Backend specific channel for the CAN interface.
:param str bustype:
Name of the interface. See
`python-can manual <https://python-can.readthedocs.io/en/latest/configuration.html#interface-names>`__
for full list of supported interfaces.
:param int bitrate:
Bitrate in bit/s.
:raises can.CanError:
When connection fails.
"""
# If bitrate has not been specified, try to find one node where bitrate
# has been specified
if "bitrate" not in kwargs:
for node in self.nodes.values():
if node.object_dictionary.bitrate:
kwargs["bitrate"] = node.object_dictionary.bitrate
break
self.bus = can.interface.Bus(*args, **kwargs)
logger.info("Connected to '%s'", self.bus.channel_info)
self.notifier = can.Notifier(self.bus, self.listeners, 1)
return self
async def main():
"""The main function that runs in the loop."""
bus = can.Bus("vcan0", bustype="virtual", receive_own_messages=True)
reader = can.AsyncBufferedReader()
logger = can.Logger("logfile.asc")
listeners = [
print_message, # Callback function
reader, # AsyncBufferedReader() listener
logger, # Regular Listener object
]
# Create Notifier with an explicit loop to use for scheduling of callbacks
loop = asyncio.get_event_loop()
notifier = can.Notifier(bus, listeners, loop=loop)
# Start sending first message
bus.send(can.Message(arbitration_id=0))
print("Bouncing 10 messages...")
for _ in range(10):
# Wait for next message from AsyncBufferedReader
msg = await reader.get_message()
# Delay response
await asyncio.sleep(0.5)
msg.arbitration_id += 1
bus.send(msg)
# Wait for last message to arrive
await reader.get_message()
print("Done!")
# Clean-up
notifier.stop()
bus.shutdown()
def __init__(self, stdscr, args):
self._stdscr = stdscr
print(f'Reading bus description file "{args.database}"...\r')
self._dbase = database.load_file(args.database,
encoding=args.encoding,
frame_id_mask=args.frame_id_mask,
prune_choices=args.prune,
strict=not args.no_strict)
self._single_line = args.single_line
self._filtered_sorted_message_names = []
self._filter = ''
self._filter_cursor_pos = 0
self._compiled_filter = None
self._formatted_messages = {}
self._playing = True
self._modified = True
self._show_filter = False
self._queue = queue.Queue()
self._nrows, self._ncols = stdscr.getmaxyx()
self._received = 0
self._discarded = 0
self._basetime = None
self._page_first_row = 0
stdscr.keypad(True)
stdscr.nodelay(True)
curses.use_default_colors()
curses.curs_set(False)
curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_GREEN)
curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_CYAN)
curses.init_pair(3, curses.COLOR_CYAN, curses.COLOR_BLACK)
bus = self.create_bus(args)
self._notifier = can.Notifier(bus, [self])
def device_init(self, rx_handle):
"""
生成一些操作对象:
实例化TX
实例化RX
:return:
"""
# 获取配置文件中的配置信息 -s
canAppName, channels, bitrate = self.get_params_from_config()
# 获取配置文件中的配置信息 -e
# 回调，实例化RX VectorBus，接收总线上的报文 -s
bus_rx = VectorBus(channel=channels[1],
app_name=canAppName,
bitrate=bitrate)
listeners = [
rx_handle # rx的回调
]
notifier = can.Notifier(bus_rx, listeners)
# 回调，实例化RX VectorBus，接收总线上的报文 -e
# 实例化TX VectorBus（需要重新实例化） -s
bus_tx = VectorBus(channel=channels[0],
app_name=canAppName,
bitrate=bitrate)
bus_tx.reset() # activate channel
# 实例化TX VectorBus（需要重新实例化） -e
return bus_tx, bus_rx, notifier
def __init__(self):
can.rc['interface'] = 'socketcan_native'
can.rc['channel'] = 'vcan0'
can.rc['bitrate'] = 500000
self.bus = Bus()
self.buffered_reader = can.BufferedReader()
self.notifier = can.Notifier(self.bus, [self.buffered_reader])
def __init__(self, interface, verbose = False, listeners = None): self.bus = Bus(interface, bustype = 'socketcan') self.verbose = verbose self.listeners = listeners self.bms = bms.bms() self.ccs = ccs.ccs() self.notifier = can.Notifier(self.bus, [self.on_message_received])
def main():
# バスの初期化
#bus = can.interface.Bus(channel = 'can0', bustype='socketcan', bitrate=250000, canfilters=None)
# すでに用意されているコールバック関数(can.Listenerクラスのon_message_received関数)をオーバーライド
call_back_function = mycan_CallBackFunction() # コールバック関数のインスタンス生成
can.Notifier(bus, [
call_back_function,
]) # コールバック関数登録
# print(bus.filters())
# print(can.BusABC.filters())
EXECUTOR = ThreadPoolExecutor(max_workers=4)
thread1 = EXECUTOR.submit(txjob)
thread2 = EXECUTOR.submit(rxjob)
while (not (thread1.done() and thread2.done())):
time.sleep(1)
return
print('start cantel terminal')
try:
thread1 = EXECUTOR.submit(txjob)
thread2 = EXECUTOR.submit(rxjob)
while (not (thread1.done() and thread2.done())):
time.sleep(1)
except KeyboardInterrupt:
print('exit')
wait1ms(100)
bus.shutdown()
wait1ms(100)
def testBufferedListenerReceives(self):
a_listener = can.BufferedReader()
notifier = can.Notifier(self.bus, [a_listener])
m = a_listener.get_message(0.2)
self.bus.send(generate_message(0xDADADA))
sleep(0.50)
self.assertIsNotNone(m)
async def record_messages(bus, node_id, extended_id, cmd_name, timeout = 5.0):
"""
Returns an async generator that yields a dictionary for each CAN message that
is received, provided that the CAN ID matches the expected value.
"""
cmd_spec = command_set[cmd_name]
cmd_id = cmd_spec[0]
fmt = '<' + ''.join([f for (n, f, s) in cmd_spec[1]]) # all little endian
reader = can.AsyncBufferedReader()
notifier = can.Notifier(bus, [reader], timeout = timeout, loop = asyncio.get_event_loop())
try:
# The timeout in can.Notifier only triggers if no new messages are received at all,
# so we need a second monitoring method.
start = time.monotonic()
while True:
msg = await reader.get_message()
if ((msg.arbitration_id == ((node_id << 5) | cmd_id)) and (msg.is_extended_id == extended_id) and not msg.is_remote_frame):
fields = struct.unpack(fmt, msg.data[:(struct.calcsize(fmt))])
res = {n: (fields[i] * s) for (i, (n, f, s)) in enumerate(cmd_spec[1])}
res['t'] = time.monotonic()
yield res
if (time.monotonic() - start) > timeout:
break
finally:
notifier.stop()
def __init__(self, bus):
self.bus = bus
# whenever a message appears on the bus, this node will try to publish it in the ros network
notifier = can.Notifier(bus, [self])
self.canpub = rospy.Publisher('data', CanFrame)
self.cansrv = rospy.Service('send_frame', CanFrameSrv,
self.send_message)
def _maybe_setup(self):
if self._setup:
return
self._reader = can.AsyncBufferedReader()
self._notifier = can.Notifier(self._can, [self._reader],
loop=asyncio.get_event_loop())
self._setup = True
def test_single_bus(self):
bus = can.Bus('test', bustype='virtual', receive_own_messages=True)
reader = can.BufferedReader()
notifier = can.Notifier(bus, [reader], 0.1)
msg = can.Message()
bus.send(msg)
self.assertIsNotNone(reader.get_message(1))
notifier.stop()
def __init__(self, buffer, updateFoo):
#initialize bus
self.canbus = can.Bus(interface='socketcan',
channel='can0',
bitrate='250000')
self.canListener = CANListener(buffer, updateFoo)
self.notifier = can.Notifier(self.canbus, [self.canListener])
def __init__(self):
self.accel_pkt_cnt = 0
self.gyro_pkt_cnt = 0
self.slope_pkt_cnt = 0
# set up Bus
self.bus = j1939.Bus(channel='can0', bustype='socketcan_native')
# set up Notifier
self.notifier = can.Notifier(self.bus, [self.general_message])
