def open_device(index=0):
device = None
if enable_use_server:
# ics.open_device() won't open a device if we have handles open already
# so we need to find them and specify which ones to connect to.
devices = ics.find_devices()
print("Opening Device {} (Open Client handles: {})...".format(dev_name(devices[index]), devices[index].NumberOfClients))
ics.open_device(devices[index])
device = devices[index]
else:
print("Opening Device...")
device = ics.open_device()
print("Opened Device %s." % dev_name(device))
return device
def __init__(self, channel, can_filters=None, **config):
"""
:param int channel:
The Channel id to create this bus with.
:param list can_filters:
See :meth:`can.BusABC.set_filters` for details.
:param use_system_timestamp:
Use system timestamp for can messages instead of the hardware time
stamp
:param str serial:
Serial to connect (optional, will use the first found if not
supplied)
:param int bitrate:
Channel bitrate in bit/s. (optional, will enable the auto bitrate
feature if not supplied)
"""
if ics is None:
raise ImportError('Please install python-ics')
super(NeoViBus, self).__init__(channel=channel,
can_filters=can_filters,
**config)
logger.info("CAN Filters: {}".format(can_filters))
logger.info("Got configuration of: {}".format(config))
self._use_system_timestamp = bool(
config.get('use_system_timestamp', False))
try:
channel = int(channel)
except ValueError:
raise ValueError('channel must be an integer')
type_filter = config.get('type_filter')
serial = config.get('serial')
self.dev = self._find_device(type_filter, serial)
ics.open_device(self.dev)
if 'bitrate' in config:
ics.set_bit_rate(self.dev, config.get('bitrate'), channel)
self.channel_info = '%s %s CH:%s' % (
self.dev.Name, self.get_serial_number(self.dev), channel)
logger.info("Using device: {}".format(self.channel_info))
self.rx_buffer = deque()
self.network = channel if channel is not None else None
def testOpenCloseByFirstFound(self):
# Open by first found
first_devices = []
for x in range(len(self.devices)):
first_devices.append(ics.open_device())
# Close by API
for device in first_devices:
ics.close_device(device)
def __init__(self, channel, can_filters=None, **config):
"""
:param channel:
The channel ids to create this bus with.
Can also be a single integer, netid name or a comma separated
string.
:type channel: int or str or list(int) or list(str)
:param list can_filters:
See :meth:`can.BusABC.set_filters` for details.
:param bool use_system_timestamp:
Use system timestamp for can messages instead of the hardware time
stamp
:param str serial:
Serial to connect (optional, will use the first found if not
supplied)
:param int bitrate:
Channel bitrate in bit/s. (optional, will enable the auto bitrate
feature if not supplied)
:param bool fd:
If CAN-FD frames should be supported.
:param int data_bitrate:
Which bitrate to use for data phase in CAN FD.
Defaults to arbitration bitrate.
"""
if ics is None:
raise ImportError('Please install python-ics')
super(NeoViBus, self).__init__(
channel=channel, can_filters=can_filters, **config)
logger.info("CAN Filters: {}".format(can_filters))
logger.info("Got configuration of: {}".format(config))
if isinstance(channel, (list, tuple)):
self.channels = channel
elif isinstance(channel, int):
self.channels = [channel]
else:
# Assume comma separated string of channels
self.channels = [ch.strip() for ch in channel.split(',')]
self.channels = [NeoViBus.channel_to_netid(ch) for ch in self.channels]
type_filter = config.get('type_filter')
serial = config.get('serial')
self.dev = self._find_device(type_filter, serial)
ics.open_device(self.dev)
if 'bitrate' in config:
for channel in self.channels:
ics.set_bit_rate(self.dev, config.get('bitrate'), channel)
fd = config.get('fd', False)
if fd:
if 'data_bitrate' in config:
for channel in self.channels:
ics.set_fd_bit_rate(
self.dev, config.get('data_bitrate'), channel)
self._use_system_timestamp = bool(
config.get('use_system_timestamp', False)
)
self.channel_info = '%s %s CH:%s' % (
self.dev.Name,
self.get_serial_number(self.dev),
self.channels
)
logger.info("Using device: {}".format(self.channel_info))
self.rx_buffer = deque()
elif opt in ("-i","--id"):
msgid = int(arg,16)
elif opt in ("-t","--cycletime"):
msgcyc = float(arg)
elif opt in ("-d", "--datafield"):
msgdtstr = str(arg)
if len(msgdtstr) > 14:
msgdtstr = msgdtstr[0:14]
elif opt in ("-f", "--timeformat"):
tmfm = str(arg)
if len(tmfm) > 5:
tmfm = tmfm[0:5]
elif opt in ("-n", "--countnum"):
txcnt = int(arg)
ics.open_device(devices[chnl])
if re.search('abs',tmfm,re.IGNORECASE):
print('Count\tSysTime(abs)\tMsgID\tData',flush=True)
elif re.search('rel',tmfm,re.IGNORECASE):
print('Count\tSysTime(rel)\tMsgID\tData',flush=True)
else:
print('Count\tSysTime(abs)\tMsgID\tData',flush=True)
while True:
if txcnt <= 0:
tx_cycle_message(chnl,msgid,msgcyc,tmfm)
elif txcnt > i:
i += 1
tx_cycle_message(chnl,msgid,msgcyc,tmfm)
else:
exit()
def __init__(self, channel, can_filters=None, **kwargs):
"""
:param channel:
The channel ids to create this bus with.
Can also be a single integer, netid name or a comma separated
string.
:type channel: int or str or list(int) or list(str)
:param list can_filters:
See :meth:`can.BusABC.set_filters` for details.
:param bool receive_own_messages:
If transmitted messages should also be received by this bus.
:param bool use_system_timestamp:
Use system timestamp for can messages instead of the hardware time
stamp
:param str serial:
Serial to connect (optional, will use the first found if not
supplied)
:param int bitrate:
Channel bitrate in bit/s. (optional, will enable the auto bitrate
feature if not supplied)
:param bool fd:
If CAN-FD frames should be supported.
:param int data_bitrate:
Which bitrate to use for data phase in CAN FD.
Defaults to arbitration bitrate.
:param override_library_name:
Absolute path or relative path to the library including filename.
"""
if ics is None:
raise ImportError("Please install python-ics")
super().__init__(channel=channel, can_filters=can_filters, **kwargs)
logger.info("CAN Filters: {}".format(can_filters))
logger.info("Got configuration of: {}".format(kwargs))
if "override_library_name" in kwargs:
ics.override_library_name(kwargs.get("override_library_name"))
if isinstance(channel, (list, tuple)):
self.channels = channel
elif isinstance(channel, int):
self.channels = [channel]
else:
# Assume comma separated string of channels
self.channels = [ch.strip() for ch in channel.split(",")]
self.channels = [NeoViBus.channel_to_netid(ch) for ch in self.channels]
type_filter = kwargs.get("type_filter")
serial = kwargs.get("serial")
self.dev = self._find_device(type_filter, serial)
with open_lock:
ics.open_device(self.dev)
if "bitrate" in kwargs:
for channel in self.channels:
ics.set_bit_rate(self.dev, kwargs.get("bitrate"), channel)
fd = kwargs.get("fd", False)
if fd:
if "data_bitrate" in kwargs:
for channel in self.channels:
ics.set_fd_bit_rate(self.dev, kwargs.get("data_bitrate"),
channel)
self._use_system_timestamp = bool(
kwargs.get("use_system_timestamp", False))
self._receive_own_messages = kwargs.get("receive_own_messages", True)
self.channel_info = "%s %s CH:%s" % (
self.dev.Name,
self.get_serial_number(self.dev),
self.channels,
)
logger.info("Using device: {}".format(self.channel_info))
self.rx_buffer = deque()
import ics
import time
def print_device_status(s):
for attr_name in dir(s):
if attr_name.startswith('_'):
continue
print(attr_name, " " * (35 - len(attr_name)), getattr(s, attr_name))
if attr_name.upper() in ('FIRE2STATUS', 'VCAN4STATUS'):
print()
print_device_status(getattr(s, attr_name))
print()
d = ics.open_device()
time.sleep(0.250) # Give the device time to send the frame
s = ics.get_device_status(d)
print_device_status(s)
def setUpClass(self):
#input() # for debugging purposes
self.dev1 = ics.open_device()
self._clear_coremini(self)
chnl = 0
tmfm = 'absolute'
try:
opts, args = getopt.getopt(sys.argv[1:],"hc:f:",["channel=","timeformat="])
except getopt.GetoptError:
usage()
exit()
for opt, arg in opts:
if opt == '-h':
usage()
exit()
elif opt in ("-c", "--channel"):
chnl = int(arg)
elif opt in ("-f", "--timeformat"):
tmfm = str(arg)
if len(tmfm) > 5:
tmfm = tmfm[0:5]
device = devices[chnl]
ics.open_device(device)
if re.search('abs',tmfm,re.IGNORECASE):
print('Time(abs)\tCAN\tID\tDir\tType\tDLC\tData',flush=True)
dump_can_chnl(chnl,1)
elif re.search('rel',tmfm,re.IGNORECASE):
print('Time(rel)\tCAN\tID\tDir\tType\tDLC\tData',flush=True)
dump_can_chnl(chnl,0)
else:
print('Time(abs)\tCAN\tID\tDir\tType\tDLC\tData',flush=True)
dump_can_chnl(chnl,1)
def testOpenClose100Times(self):
for x in range(100):
ics.open_device(self.devices[0])
ics.close_device(self.devices[0])
def testOpenCloseBySerial(self):
# Open by serial number
for device in self.devices:
d = ics.open_device(device.SerialNumber)
ics.close_device(d)
def testOpenCloseByFind(self):
# Open by ics.NeoDevice
for device in self.devices:
ics.open_device(device)
ics.close_device(device)
def setUpClass(self):
devices = ics.find_devices(ics.NEODEVICE_FIRE)
ics.open_device(devices[0])
ics.open_device(devices[1])
self.dev1 = devices[0]
self.dev2 = devices[1]
