def test_deprecated_loop_arg(recwarn):
warnings.simplefilter("always")
can.AsyncBufferedReader(loop=asyncio.get_event_loop())
assert len(recwarn) > 0
assert recwarn.pop(DeprecationWarning)
recwarn.clear()
# assert that no warning is shown when loop argument is not used
can.AsyncBufferedReader()
assert len(recwarn) == 0
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()
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()
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()
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 _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
async def main(self):
loop = asyncio.get_event_loop()
self.reader = can.AsyncBufferedReader()
notifier = can.Notifier(self.bus, [self.reader], loop=loop)
await asyncio.gather(
self.emit_status(),
self.check_timeout(),
self.read_messages(),
)
notifier.stop()
async def read_elster_canbus(topic: PublishSubscribeTopic[ElsterFrame],
bus: can.Bus):
reader = can.AsyncBufferedReader()
with stopping(
can.Notifier(bus=bus,
listeners=[reader],
loop=asyncio.get_event_loop())):
async for message in reader:
elster_frame = parse_can_message(message)
topic.publish(elster_frame)
async def run_it():
with can.Bus("test",
interface="virtual",
receive_own_messages=True) as bus:
reader = can.AsyncBufferedReader()
notifier = can.Notifier(bus, [reader],
0.1,
loop=asyncio.get_running_loop())
bus.send(can.Message())
recv_msg = await asyncio.wait_for(reader.get_message(), 0.5)
self.assertIsNotNone(recv_msg)
notifier.stop()
def test_asyncio_notifier(self):
loop = asyncio.get_event_loop()
bus = can.Bus("test", bustype="virtual", receive_own_messages=True)
reader = can.AsyncBufferedReader()
notifier = can.Notifier(bus, [reader], 0.1, loop=loop)
msg = can.Message()
bus.send(msg)
future = asyncio.wait_for(reader.get_message(), 1.0)
recv_msg = loop.run_until_complete(future)
self.assertIsNotNone(recv_msg)
notifier.stop()
bus.shutdown()
async def main(self):
"""
Run the receive and send coroutines
"""
loop = asyncio.get_event_loop()
self.reader = can.AsyncBufferedReader()
notifier = can.Notifier(self.bus, [self.reader], loop=loop)
await asyncio.gather(
self.send_message(),
self.receive_status(),
)
notifier.stop()
async def main():
can0 = can.Bus('can0',
bustype='socketcan_ctypes',
receive_own_messages=False)
reader = can.AsyncBufferedReader()
logger = can.Logger('logfile.asc')
id17VoltCurr = 124045395
# filters = []
# filters.append({'can_id': idMsgVoltageCurr[0], 'can_mask': 134217727, 'extended': False})
# can0.set_filters(filters)
listeners = [
# listen_batre, # Callback function
reader, # AsyncBufferedReader() listener
logger, # Regular Listener object
handleVoltCurr,
handleReadMosfetState,
handleCellVBatch1,
handleCellVBatch2,
handleCellVBatch3,
handleCellVBatch4,
# listen_sensor_arus
]
# listeners1 = [
# ini_test, # 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()
# notifier1 = can.Notifier(can0, listeners1, loop=loop)
notifier = can.Notifier(can0, listeners, loop=loop)
# Start sending first message
# can0.send(can.Message(arbitration_id=0))
print('1 : Bouncing 10 messages...')
for _ in range(16):
# Wait for next message from AsyncBufferedReader
msg = await reader.get_message()
# print(f'ini can msg {msg}')
# Delay response
# await asyncio.sleep(0.1)
# msg.arbitration_id += 1
# can0.send(msg)
# Wait for last message to arrive
await reader.get_message()
print('Done! 1')
# Clean-up
notifier.stop()
# notifier1.stop()
can0.shutdown()
async def websocket_producer_handler(websocket, path):
socketcan_producer = can.AsyncBufferedReader()
notifier.add_listener(socketcan_producer)
while True:
msg = await socketcan_producer.get_message()
msg = can.interfaces.socketcan.socketcan.build_can_frame(
msg) # Convert from can.Message to bytes
try:
await websocket.send(msg)
except websockets.exceptions.ConnectionClosed:
break
notifier.remove_listener(socketcan_producer)
async def main():
can0 = can.Bus(channel='can0',
bustype='socketcan',
receive_own_messages=False)
reader = can.AsyncBufferedReader()
logger = can.Logger('canlog.log')
listeners = [
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)
client = mqtt.Client("hoval-client")
client.username_pw_set(username=broker_username, password=broker_password)
client.connect(broker)
last_query = time.time()
while True:
polled_data
# Wait for next message from AsyncBufferedReader
msg = await reader.get_message()
parsed = parse(msg)
if parsed:
logging.info(parsed)
ret = client.publish("hoval-gw/" + parsed[0], parsed[1])
if ret[0] != 0:
client.connect(broker)
if time.time() - last_query >= POLLING_INTERVAL:
start_id = 0
for i in polled_data:
data = query(i)
try:
arb_id = start_id % 0x10
arb_id = (0x1F0 + arb_id) << 16
arb_id += 0x0801 # This is the fixed address?
msg = can.Message(arbitration_id=arb_id,
data=list(data),
is_extended_id=True)
can0.send(msg)
start_id += 1
except can.CanError as e:
logging.exception(e)
last_query = time.time()
# Clean-up
notifier.stop()
can0.shutdown()
async def main1():
can0 = can.Bus('can0', bustype='socketcan_ctypes')
reader = can.AsyncBufferedReader()
logger = can.Logger('logfile.asc')
listeners = [
reader, # AsyncBufferedReader() listener
logger, # Regular Listener object
# handleVoltCurr,
# handleReadMosfetState,
# handleCellVBatch1,
# handleCellVBatch2,
# handleCellVBatch3,
# # handleCellVBatch4,
]
# Create Notifier with an explicit loop to use for scheduling of callbacks
loop = asyncio.get_event_loop()
notifier = can.Notifier(can0, listeners, loop=loop)
i = 0
n = 16
a = []
print('2 : Bouncing 10 messages...')
while i < n:
print(i)
msg = await reader.get_message()
if msg.arbitration_id in idMsgVoltageCurr:
dock = idMsgVoltageCurr.index(msg.arbitration_id) + 1
a.append(msg.arbitration_id)
print(msg.arbitration_id)
# red.lset('pms_active', dock, 1)
i += 1
# Wait for last message to arrive
await reader.get_message()
print(a)
print('Done! 2')
# Clean-up
notifier.stop()
can0.shutdown()
async def listen(self, callback):
reader = can.AsyncBufferedReader()
logger = can.Logger(
f"log/{ datetime.now().isoformat(timespec='seconds') }.log")
# Set up listeners and add callback functions
listeners = [
reader, # AsyncBufferedReader() listener
logger, # Regular Listener object
]
listeners.extend(callback)
loop = asyncio.get_event_loop()
# Create Notifier with an explicit loop to use for scheduling of callbacks
self.notifier = can.Notifier(self.can_bus,
listeners,
timeout=1.0,
loop=loop)
while True:
# Wait for next message from AsyncBufferedReader
msg = await reader.get_message()
self.history.append(msg)
def _starting_async_listener(self):
self.reader = can.AsyncBufferedReader()
listeners = [self.reader]
loop = asyncio.get_event_loop()
self.notifier = can.Notifier(self.network, listeners, loop=loop)
