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)