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(): """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 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 main(): """The transcoder""" with can.LogReader(sys.argv[1]) as reader: with can.Logger(sys.argv[2]) as writer: for msg in reader: # pylint: disable=not-an-iterable writer.on_message_received(msg)
def main(): """The transcoder""" with can.LogReader(sys.argv[1]) as reader: with can.Logger(sys.argv[2]) as writer: for msg in reader: writer.on_message_received(msg)
def test_filetype_to_instance(extension, klass): print("testing: {}".format(extension)) try: with tempfile.NamedTemporaryFile(suffix=extension, delete=False) as my_file: filename = my_file.name with can.Logger(filename) as writer: self.assertIsInstance(writer, klass) finally: os.remove(filename)
def __init__(self, mqttAgent): bus = can.Bus(interface='socketcan', channel='can0', receive_own_messages=True) notifier = can.Notifier(bus, [can.Logger("recorded.log"), can.Parser(self)]) print("CAN Thread started") self.agent = mqttAgent self.opposites = ["BLDoor", "BRDoor", "FLDoor", "FRDoor"]
def set_can(self, interface, channel, bitrate, db=None, receive_own_messages=False, test_name=None): """ Set the CAN BUS Keyword arguments: interface -- can interface (socketcan, vector, ...) channel -- can channel (can0, vcan0, ...) bitrate -- can bitrate (125000, 500000, ...) db -- can database (arxml,dbc,kcd,sym,cdd) test_name -- Name of test case See https://cantools.readthedocs.io/en/latest/#about See https://python-can.readthedocs.io/en/master/interfaces.html """ dt_now = dt.datetime.now() self.interface = interface self.channel = channel self.bitrate = bitrate self.db_file = db self.receive_own_messages = receive_own_messages self.bus = can.Bus(bustype=self.interface, channel=self.channel, bitrate=self.bitrate, receive_own_messages=self.receive_own_messages) # Check if the db file is present and load it if db is not None and db != 'None': self.db = cantools.database.load_file(db) self.db_default_node = self.db.nodes[0].name #Get current directory of the proce ie:where you are when launching the test path = os.getcwd() #add outputs and data as new path for logfile path = path + "/outputs" if not os.path.isdir(path): os.mkdir(path) path = path + ("/%d%02d%02d/" % (dt_now.year, dt_now.month, dt_now.day)) try: os.mkdir(path) except FileExistsError: pass #file name for the log file with its absolute path output_candump_filename = path + ( "%s_%d%02d%02d_%02d%02d%02d" % (test_name, dt_now.year, dt_now.month, dt_now.day, dt_now.hour, dt_now.minute, dt_now.second)) #initialize logger with file name self.logger = can.Logger(output_candump_filename + ".log") #add notifier for log self.notifier = can.Notifier(self.bus, [self.logger]) self.is_set = True
def main(): bus = can.interface.Bus('can0', bustype='socketcan') logger = can.Logger(None) notifier = can.Notifier(bus, [logger], timeout=0.1) try: while True: time.sleep(1) except KeyboardInterrupt: print('Shutdown') bus.shutdown()
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()
def initcanlogger(self): ''' stop old if running and create new logger with filename from timestamp''' if self.canlogger is not None: # stop old logging try: self.canlogger.stop() except Exception as e: pass timestr = datetime.now().strftime("%Y-%m-%dT%H%M%S") logfilname = f'{self.logpath}//{self.can_channel}_{timestr}_log.blf' self.canlogger = can.Logger(filename=logfilname) self.logger.debug(f"Init canlogger : {logfilname}")
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()
def start(self, stop_event): bus = can.Bus(interface='virtual', channel='vcan0') bus.set_filters(self.filters) # asynchronous notifier notifier = can.Notifier(bus, [can.Logger("recorded.log"), BetterPrinter()]) while True: if stop_event.is_set(): notifier.stop() bus.shutdown() break
def start(self, stop_event): self.bus.set_filters(self.filters) # asynchronous notifier notifier = can.Notifier(self.bus, [can.Logger("recorded.log"), BetterPrinter()]) while True: if stop_event.is_set(): notifier.stop() self.bus.shutdown() break self.request_fuel_diagnostic() time.sleep(self.diagnostic_delay_factor)
def testLoggerTypeResolution(self): def test_filetype_to_instance(extension, klass): print("testing: {}".format(extension)) try: with tempfile.NamedTemporaryFile(suffix=extension, delete=False) as my_file: filename = my_file.name with can.Logger(filename) as writer: self.assertIsInstance(writer, klass) finally: os.remove(filename) test_filetype_to_instance(".asc", can.ASCWriter) test_filetype_to_instance(".blf", can.BLFWriter) test_filetype_to_instance(".csv", can.CSVWriter) test_filetype_to_instance(".db", can.SqliteWriter) test_filetype_to_instance(".log", can.CanutilsLogWriter) test_filetype_to_instance(".txt", can.Printer) with can.Logger(None) as logger: self.assertIsInstance(logger, can.Printer)
def test_extension_matching(self): for suffix, (writer, reader) in self.message_writers_and_readers.items(): suffix_variants = [ suffix.upper(), suffix.lower(), "".join( [c.upper() if i % 2 else c for i, c in enumerate(suffix)]), ] for suffix_variant in suffix_variants: tmp_file = tempfile.NamedTemporaryFile(suffix=suffix_variant, delete=False) tmp_file.close() try: with can.Logger(tmp_file.name) as logger: assert type(logger) == writer if reader is not None: with can.LogReader(tmp_file.name) as player: assert type(player) == reader finally: os.remove(tmp_file.name)
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()
def set_can(self, interface, channel, bitrate, db=None, test_name=None): """ Set the CAN BUS Keyword arguments: interface -- can interface (socketcan, vector, ...) channel -- can channel (can0, vcan0, ...) bitrate -- can bitrate (125000, 500000, ...) db -- can database (arxml,dbc,kcd,sym,cdd) test_name -- Name of test case See https://cantools.readthedocs.io/en/latest/#about See https://python-can.readthedocs.io/en/master/interfaces.html """ dt_now = dt.datetime.now() self.interface = interface self.channel = channel self.bitrate = bitrate self.db_file = db self.bus = can.interface.Bus(bustype=self.interface, channel=self.channel, bitrate=self.bitrate) self.logbus = can.ThreadSafeBus(interface=self.interface, channel=self.channel) if db is not None and db != 'None': self.db = cantools.database.load_file(db) self.db_default_node = self.db.nodes[0].name path = os.getcwd() path = path + "/outputs/" + ("%d%02d%02d/" % (dt_now.year, dt_now.month, dt_now.day)) try: os.mkdir(path) except FileExistsError: pass output_candump_filename = path + ( "%s_%d%02d%02d_%02d%02d%02d" % (test_name, dt_now.year, dt_now.month, dt_now.day, dt_now.hour, dt_now.minute, dt_now.second)) self.logger = can.Logger(output_candump_filename) self.notifier = can.Notifier(self.logbus, [self.logger]) self.is_set = True
def read_iterate_msg(bus=None): # create a bus instance # many other interfaces are supported as well if bus is None: bus = can.Bus(interface='socketcan', channel='vcan0', recieve_own_messages=True) #send a message """ message = can.Message(arbitration_id=1234, is_extended_id=True, data=[0x11, 0x22, 0x33]) bus.send(message, timeout=0.2) """ # iterate over received messages """ for msg in bus: print("{}: {}".format(msg.arbitration_id, msg.data)) """ # or use an asynchronous notifier notifier = can.Notifier(bus, [can.Logger("recorded.log"), can.Printer()])
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 testLoggerTypeResolutionUnsupportedFileTypes(self): for should_fail_with in ["", ".", ".some_unknown_extention_42"]: with self.assertRaises(ValueError): with can.Logger( should_fail_with): # make sure we close it anyways pass
# import the library import can # create a bus instance # many other interfaces are supported as well (see below) bus = can.Bus(interface='socketcan', channel='vcan0', receive_own_messages=True) # send a message message = can.Message(arbitration_id=123, is_extended_id=True, data=[0x11, 0x22, 0x33]) bus.send(message, timeout=0.2) # iterate over received messages for msg in bus: print("{:X}: {}".format(msg.arbitration_id, msg.data)) # or use an asynchronous notifier notifier = can.Notifier(bus, [can.Logger("recorded.log"), can.Printer()])
import can bus0 = can.interface.Bus(bustype='socketcan', channel='can0', bitrate=500000) bus1 = can.interface.Bus(bustype='socketcan', channel='can1', bitrate=500000) # or use an asynchronous notifier notifier0 = can.Notifier(bus0, [can.Logger("recorded_can0.asc")]) notifier1 = can.Notifier(bus1, [can.Logger("recorded_can1.asc")]) import time time.sleep(1000 * 10)
def record_message(self, bus, BLFfile_name): # bus can be a bus or list listeners = [can.Logger(BLFfile_name)] self.notifier_logger = can.Notifier(bus, listeners) return self.notifier_logger
'critical', 'error', 'warning', 'info', 'debug', 'subdebug' ][min(5, verbosity)] can.set_logging_level(logging_level_name) can_filters = [] if len(results.filter) > 0: print('Adding filter/s', results.filter) for filt in results.filter: if ':' in filt: _ = filt.split(":") can_id, can_mask = int(_[0], base=16), int(_[1], base=16) elif "~" in filt: can_id, can_mask = filt.split("~") can_id = int(can_id, base=16) | 0x20000000 # CAN_INV_FILTER can_mask = int(can_mask, base=16) & socket.CAN_ERR_FLAG can_filters.append({"can_id": can_id, "can_mask": can_mask}) bus = can.interface.Bus(results.channel, bustype=results.interface, can_filters=can_filters) print('Can Logger (Started on {})\n'.format(datetime.datetime.now())) logger = can.Logger(results.log_file) notifier = can.Notifier(bus, [logger], timeout=0.1) try: while True: time.sleep(1) except KeyboardInterrupt: bus.shutdown() notifier.stop()
def test_filetype_to_instance(extension, klass): can_logger = can.Logger("test.{}".format(extension)) self.assertIsInstance(can_logger, klass) can_logger.stop()
def testLogger(self): self.assertIsInstance(can.Logger("test.asc"), can.ASCWriter) self.assertIsInstance(can.Logger("test.csv"), can.CSVWriter) self.assertIsInstance(can.Logger("test.db"), can.SqliteWriter) self.assertIsInstance(can.Logger("test.txt"), can.Printer)
data = [random.randint(0, 15) for i in range(0, 8)] msg = can.Message(is_extended_id=False, arbitration_id=0x7E0, data=data) bus.send(msg) time.sleep(0.5) self.finished = True def stop(self): self.running = False if __name__ == "__main__": # RX part bus_rx = can.interface.Bus('virtual_ch', bustype='virtual') logger = can.Logger("logfile.asc") # save log to asc file listeners = [ print_message, # Callback function, print the received messages logger, # save received messages to asc file ] notifier = can.Notifier(bus_rx, listeners) # TX part bus_tx = can.interface.Bus('virtual_ch', bustype='virtual') tx_service = tx_thread_cl(bus_tx) tx_service.start() running = True while running: input() running = False
import can #import canapp import RPi.GPIO as GPIO db_path = '/home/pi/obd_analyzer/data/storage.db' # Create a can network interface with a specific name os.system('sudo ip link add dev can0 type can') os.system('sudo ip link set can0 up type can bitrate 250000') #os.system('ip -details -statistics link show can0') # Create can bus object bus = can.interface.Bus(channel='can0', bustype='socketcan') # Create notifier object notifier = can.Notifier(bus, [can.Logger(db_path)]) # Set GPIO21 as output GPIO.setmode(GPIO.BCM) runled = 21 GPIO.setup(runled, GPIO.OUT) print("Obd analyzer start!") while True: GPIO.output(runled, GPIO.HIGH) time.sleep(1) GPIO.output(runled, GPIO.LOW) time.sleep(1) # ts = time.strftime('%Y%m%d', time.localtime()) # canapp.printdb2csv(db_path, ts)