def test_general(self):
messages = [
Message(timestamp=50.0),
Message(timestamp=50.0),
Message(timestamp=50.0 + 0.05),
Message(timestamp=50.0 + 0.05 + 0.08),
Message(timestamp=50.0), # back in time
]
sync = MessageSync(messages, gap=0.0)
start = time()
collected = []
timings = []
for message in sync:
collected.append(message)
now = time()
timings.append(now - start)
start = now
self.assertMessagesEqual(messages, collected)
self.assertEqual(len(timings), len(messages), "programming error in test code")
self.assertTrue(0.0 <= timings[0] < inc(0.005), str(timings[0]))
self.assertTrue(0.0 <= timings[1] < inc(0.005), str(timings[1]))
self.assertTrue(0.045 <= timings[2] < inc(0.055), str(timings[2]))
self.assertTrue(0.075 <= timings[3] < inc(0.085), str(timings[3]))
self.assertTrue(0.0 <= timings[4] < inc(0.005), str(timings[4]))
def test_skip(self):
messages = copy(TEST_FEWER_MESSAGES)
sync = MessageSync(messages, skip=0.005, gap=0.0)
before = time()
collected = list(sync)
after = time()
took = after - before
# the handling of the messages itself also takes some time:
# ~0.001 s/message on a ThinkPad T560 laptop (Ubuntu 18.04, i5-6200U)
assert 0 < took < inc(len(messages) * (0.005 + 0.003)), "took: {}s".format(took)
self.assertMessagesEqual(messages, collected)
def test_gap(timestamp_1, timestamp_2):
"""This method is alone so it can be parameterized."""
messages = [
Message(arbitration_id=0x1, timestamp=timestamp_1),
Message(arbitration_id=0x2, timestamp=timestamp_2),
]
sync = MessageSync(messages, gap=0.1)
gc.disable()
before = time()
collected = list(sync)
after = time()
gc.enable()
took = after - before
assert 0.1 <= took < inc(0.3)
assert messages == collected
def main():
parser = argparse.ArgumentParser(
"python -m can.player",
description="Replay CAN traffic.")
parser.add_argument("-f", "--file_name", dest="log_file",
help="""Path and base log filename, for supported types see can.LogReader.""",
default=None)
parser.add_argument("-v", action="count", dest="verbosity",
help='''Also print can frames to stdout.
You can add several of these to enable debugging''', default=2)
parser.add_argument('-c', '--channel',
help='''Most backend interfaces require some sort of channel.
For example with the serial interface the channel might be a rfcomm device: "/dev/rfcomm0"
With the socketcan interfaces valid channel examples include: "can0", "vcan0"''')
parser.add_argument('-i', '--interface', dest="interface",
help='''Specify the backend CAN interface to use. If left blank,
fall back to reading from configuration files.''',
choices=can.VALID_INTERFACES)
parser.add_argument('-b', '--bitrate', type=int,
help='''Bitrate to use for the CAN bus.''')
parser.add_argument('--ignore-timestamps', dest='timestamps',
help='''Ignore timestamps (send all frames immediately with minimum gap between frames)''',
action='store_false')
parser.add_argument('-g', '--gap', type=float, help='''<s> minimum time between replayed frames''',
default=0.0001)
parser.add_argument('-s', '--skip', type=float, default=60*60*24,
help='''<s> skip gaps greater than 's' seconds''')
parser.add_argument('infile', metavar='input-file', type=str,
help='The file to replay. For supported types see can.LogReader.')
# print help message when no arguments were given
if len(sys.argv) < 2:
parser.print_help(sys.stderr)
import errno
raise SystemExit(errno.EINVAL)
results = parser.parse_args()
verbosity = results.verbosity
logging_level_name = ['critical', 'error', 'warning', 'info', 'debug', 'subdebug'][min(5, verbosity)]
can.set_logging_level(logging_level_name)
config = {"single_handle": True}
if results.interface:
config["interface"] = results.interface
if results.bitrate:
config["bitrate"] = results.bitrate
bus = Bus(results.channel, **config)
reader = LogReader(results.infile)
in_sync = MessageSync(reader, timestamps=results.timestamps,
gap=results.gap, skip=results.skip)
print('Can LogReader (Started on {})'.format(datetime.now()))
try:
for m in in_sync:
if verbosity >= 3:
print(m)
bus.send(m)
except KeyboardInterrupt:
pass
finally:
bus.shutdown()
reader.stop()
def main():
parser = argparse.ArgumentParser(
"python -m can.player", description="Replay CAN traffic."
)
parser.add_argument(
"-f",
"--file_name",
dest="log_file",
help="""Path and base log filename, for supported types see can.LogReader.""",
default=None,
)
parser.add_argument(
"-v",
action="count",
dest="verbosity",
help="""Also print can frames to stdout.
You can add several of these to enable debugging""",
default=2,
)
parser.add_argument(
"-c",
"--channel",
help='''Most backend interfaces require some sort of channel.
For example with the serial interface the channel might be a rfcomm device: "/dev/rfcomm0"
With the socketcan interfaces valid channel examples include: "can0", "vcan0"''',
)
parser.add_argument(
"-i",
"--interface",
dest="interface",
help="""Specify the backend CAN interface to use. If left blank,
fall back to reading from configuration files.""",
choices=can.VALID_INTERFACES,
)
parser.add_argument(
"-b", "--bitrate", type=int, help="""Bitrate to use for the CAN bus."""
)
parser.add_argument("--fd", help="Activate CAN-FD support", action="store_true")
parser.add_argument(
"--data_bitrate",
type=int,
help="""Bitrate to use for the data phase in case of CAN-FD.""",
)
parser.add_argument(
"--ignore-timestamps",
dest="timestamps",
help="""Ignore timestamps (send all frames immediately with minimum gap between frames)""",
action="store_false",
)
parser.add_argument(
"--error-frames",
help="Also send error frames to the interface.",
action="store_true",
)
parser.add_argument(
"-g",
"--gap",
type=float,
help="""<s> minimum time between replayed frames""",
default=0.0001,
)
parser.add_argument(
"-s",
"--skip",
type=float,
default=60 * 60 * 24,
help="""<s> skip gaps greater than 's' seconds""",
)
parser.add_argument(
"infile",
metavar="input-file",
type=str,
help="The file to replay. For supported types see can.LogReader.",
)
# print help message when no arguments were given
if len(sys.argv) < 2:
parser.print_help(sys.stderr)
raise SystemExit(errno.EINVAL)
results = parser.parse_args()
verbosity = results.verbosity
logging_level_name = ["critical", "error", "warning", "info", "debug", "subdebug"][
min(5, verbosity)
]
can.set_logging_level(logging_level_name)
error_frames = results.error_frames
config = {"single_handle": True}
if results.interface:
config["interface"] = results.interface
if results.bitrate:
config["bitrate"] = results.bitrate
if results.fd:
config["fd"] = True
if results.data_bitrate:
config["data_bitrate"] = results.data_bitrate
bus = Bus(results.channel, **config)
reader = LogReader(results.infile)
in_sync = MessageSync(
reader, timestamps=results.timestamps, gap=results.gap, skip=results.skip
)
print(f"Can LogReader (Started on {datetime.now()})")
try:
for m in in_sync:
if m.is_error_frame and not error_frames:
continue
if verbosity >= 3:
print(m)
bus.send(m)
except KeyboardInterrupt:
pass
finally:
bus.shutdown()
reader.stop()
def main() -> None:
parser = argparse.ArgumentParser(description="Replay CAN traffic.")
_create_base_argument_parser(parser)
parser.add_argument(
"-f",
"--file_name",
dest="log_file",
help="Path and base log filename, for supported types see can.LogReader.",
default=None,
)
parser.add_argument(
"-v",
action="count",
dest="verbosity",
help="""Also print can frames to stdout.
You can add several of these to enable debugging""",
default=2,
)
parser.add_argument(
"--ignore-timestamps",
dest="timestamps",
help="""Ignore timestamps (send all frames immediately with minimum gap between frames)""",
action="store_false",
)
parser.add_argument(
"--error-frames",
help="Also send error frames to the interface.",
action="store_true",
)
parser.add_argument(
"-g",
"--gap",
type=float,
help="<s> minimum time between replayed frames",
default=0.0001,
)
parser.add_argument(
"-s",
"--skip",
type=float,
default=60 * 60 * 24,
help="<s> skip gaps greater than 's' seconds",
)
parser.add_argument(
"infile",
metavar="input-file",
type=str,
help="The file to replay. For supported types see can.LogReader.",
)
# print help message when no arguments were given
if len(sys.argv) < 2:
parser.print_help(sys.stderr)
raise SystemExit(errno.EINVAL)
results = parser.parse_args()
verbosity = results.verbosity
error_frames = results.error_frames
with _create_bus(results) as bus:
with LogReader(results.infile) as reader:
in_sync = MessageSync(
cast(Iterable[Message], reader),
timestamps=results.timestamps,
gap=results.gap,
skip=results.skip,
)
print(f"Can LogReader (Started on {datetime.now()})")
try:
for message in in_sync:
if message.is_error_frame and not error_frames:
continue
if verbosity >= 3:
print(message)
bus.send(message)
except KeyboardInterrupt:
pass