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)
