def test_encoders_overflow(self):
q = MagicMock()
logger = MagicMock()
logger.write = MagicMock(return_value=22)
bus = BusHandler(logger=logger,
out={
'can': [],
'encoders': [(q, 'encoders')],
'emergency_stop': [],
'pose2d': [],
'buttons': []
})
eduro = Eduro(config={}, bus=bus)
sync = CAN_packet(0x80, [])
enc_left = CAN_packet(0x181, [0xff, 0xff, 0xff, 0x7f])
bus.queue.put((42, 'can', enc_left))
bus.queue.put((123, 'can', sync))
enc_left = CAN_packet(0x181, [0x01, 0x00, 0x00, 0x80])
bus.queue.put((44, 'can', enc_left))
sync = CAN_packet(0x80, [])
bus.queue.put((123, 'can', sync))
bus.shutdown()
eduro.run()
self.assertEqual(
q.put.call_args_list,
[call((22, 'encoders', [0, 0])),
call((22, 'encoders', [2, 0]))])
def test_two_modules(self):
logger = MagicMock()
handler2 = BusHandler(logger)
handler1 = BusHandler(logger, out={'raw':[(handler2.queue, 42)]})
logger.write = MagicMock(return_value=123)
handler1.publish('raw', b"Hello!")
self.assertEqual(handler2.listen(), (123, 42, b"Hello!"))
def test_bus_sleep(self):
logger = MagicMock()
bus = BusHandler(logger, out={})
bus.sleep(0.1)
bus = LogBusHandler(logger, inputs={}, outputs={})
bus.sleep(0.1)
bus = LogBusHandlerInputsOnly(logger, inputs={})
bus.sleep(0.1)
def test_publish_status(self):
q = MagicMock()
logger=MagicMock()
logger.write = MagicMock(return_value=135)
bus = BusHandler(logger=logger, out={'status':[(q, 'status'),], 'can':[]})
spider = Spider(config={}, bus=bus)
spider.can_bridge_initialized = True # skip initialization
self.assertEqual(CAN_packet(0x200, [0, 0x80]), b'@\x02\x00\x80')
bus.queue.put((123, 'raw', b'@\x02\x00\x80'))
bus.shutdown()
spider.run()
q.put.assert_called_once_with((135, 'status', ([0x8000, None])))
def test_update(self):
empty_config = {}
bus = BusHandler(name='mynode', logger=MagicMock)
node = Node(config=empty_config, bus=bus)
bus.queue.put((timedelta(seconds=1), 'vel', 3))
node.update()
self.assertEqual(node.time, timedelta(seconds=1))
self.assertEqual(node.vel, 3)
bus2 = BusHandler(name='mynode2', logger=MagicMock)
node = Node(config=empty_config, bus=bus2)
self.assertNotIn('vel', dir(node))
def test_compression(self):
logger = MagicMock()
logger.register = MagicMock(return_value=1)
bus = BusHandler(logger, out={'raw': []}, name='tcp_point_data')
# TODO proper definition what should be compressed - now hardcoded to name "tcp_point_data"
self.assertTrue(bus.compressed_output)
bus.publish('raw', b'\00' * 10000)
logger.write.assert_called_once_with(
1,
b'x\x9c\xed\xc1\x01\r\x00\x00\x08\x03 #\xbc\x85\xfdC\xd8\xcb\x1e\x1fp\x9b'
+
b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x0f\x9f\xba\x00\xfd'
)
def test_sync(self):
q = MagicMock()
logger = MagicMock()
logger.write = MagicMock(return_value=135)
bus = BusHandler(logger=logger,
out={'can': [], 'encoders': [], 'emergency_stop': [],
'pose2d': [(q, 'pose2d'),], 'buttons': []})
eduro = Eduro(config={}, bus=bus)
sync = CAN_packet(0x80, [])
bus.queue.put((123, 'can', sync))
bus.shutdown()
eduro.run()
q.put.assert_called_once_with((135, 'pose2d', [0, 0, 0]))
def test_processing(self):
config = {}
logger = MagicMock()
robot_bus = BusHandler(logger, out={}, name='robot')
bus = BusHandler(logger,
out={'orientation':[(robot_bus.queue, 'orientation')], 'rotation':[]},
name='imu')
imu = IMU(config, bus=bus)
imu.start()
imu.bus.queue.put((123, 'raw', self.nmea_line))
data = robot_bus.listen()
imu.request_stop()
imu.join()
def test_bus_sleep(self):
logger = MagicMock()
bus = BusHandler(logger, out={})
bus.sleep(0.1)
bus = LogBusHandler(logger, inputs={}, outputs={})
bus.sleep(0.1)
bus = LogBusHandlerInputsOnly(logger, inputs={})
bus.sleep(0.1)
def test_node(self):
config = {}
# q = MagicMock()
logger = MagicMock()
robot_bus = BusHandler(logger, out={}, name='robot')
bus = BusHandler(logger,
out={'orientation':[(robot_bus.queue, 'orientation')], 'rotation':[]},
name='imu')
imu = LordIMU(config, bus=bus)
imu.start()
imu.bus.queue.put((123, 'raw', SAMPLE_DATA))
imu.request_stop()
imu.join()
self.assertEqual(imu.raw, SAMPLE_DATA)
def test_autodetect(self):
SAMPLE_DATA = b'1|cmd=home\n'
logger = MagicMock()
robot_bus = BusHandler(logger, out={}, name='robot')
bus = BusHandler(logger,
out={'raw':[(robot_bus.queue, 'raw')]},
name='lora')
c = LoRa(bus=bus, config={'device_id': 4})
c.start()
c.bus.queue.put((123, 'raw', SAMPLE_DATA))
c.request_stop()
c.join()
self.assertEqual(c.device_id, 4)
def test_buttons(self):
# is there a simpler way without starting the Thread??
q = MagicMock()
logger = MagicMock()
logger.write = MagicMock(return_value=42)
bus = BusHandler(logger=logger,
out={'can': [], 'encoders': [], 'emergency_stop': [],
'pose2d': [], 'buttons': [(q, 'buttons')]})
eduro = Eduro(config={}, bus=bus)
buttons_msg = CAN_packet(0x28A, [0, 0])
bus.queue.put((42, 'can', buttons_msg))
bus.shutdown()
eduro.run()
q.put.assert_called_once_with((42, 'buttons', {'blue_selected': True, 'cable_in': False}))
def test_usage(self):
empty_config = {}
bus = BusHandler(name='mynode', logger=MagicMock)
node = Node(config=empty_config, bus=bus)
node.start()
node.request_stop()
node.join()
def test_processing(self):
config = {}
logger = MagicMock()
robot_bus = BusHandler(logger, out={}, name='robot')
bus = BusHandler(logger,
out={
'orientation': [(robot_bus.queue, 'orientation')],
'rotation': []
},
name='imu')
imu = IMU(config, bus=bus)
imu.start()
imu.bus.queue.put((123, 'raw', self.nmea_line))
data = robot_bus.listen()
imu.request_stop()
imu.join()
def __init__(self, config, logger, application=None):
self.modules = {}
que = {}
for module_name, module_config in config['modules'].items():
out, slots = {}, {}
for output_type in module_config['out']:
out[output_type] = []
slots[output_type] = []
bus = BusHandler(logger, out=out, slots=slots, name=module_name)
que[module_name] = bus.queue
module_class = module_config['driver']
if module_class == 'application':
assert application is not None # external application required
module = application(module_config['init'], bus=bus)
else:
module = get_class_by_name(module_class)(module_config['init'],
bus=bus)
self.modules[module_name] = module
for from_module, to_module in config['links']:
(from_driver, from_name), (
to_driver,
to_name) = from_module.split('.'), to_module.split('.')
if to_name.startswith('slot_'):
self.modules[from_driver].bus.slots[from_name].append(
getattr(self.modules[to_driver], to_name))
else:
self.modules[from_driver].bus.out[from_name].append(
(self.modules[to_driver].bus.queue, to_name))
def test_2nd_loop(self):
q = MagicMock()
logger = MagicMock()
logger.write = MagicMock(return_value=135)
bus = BusHandler(logger=logger,
out={
'raw': [(q, 'raw')],
'encoders': [],
'emergency_stop': [],
'pose2d': [],
'buttons': []
})
robot = Cortexpilot(config={}, bus=bus)
bus.queue.put(
(123, 'raw', b'\x00\x00\x10\x01\x01Robik V4.0.2\x00\x8f'))
robot.start()
robot.request_stop()
robot.join()
self.assertEqual(
q.put.call_args_list,
[
call((135, 'raw',
b'\x00\x00\x03\x01\x01\xfb')), # request version
call((135, 'raw',
bytes.fromhex('00000f010d000000000000000040010000a2')
)) # cmd
])
def test_start_stop(self):
config = {}
logger = MagicMock()
bus = BusHandler(logger, out={'raw': [], 'scan': []}, name='lidar')
lidar = SICKLidar(config, bus=bus)
lidar.start()
lidar.request_stop()
lidar.join()
def test_autodetect_bug(self):
logger = MagicMock()
robot_bus = BusHandler(logger, out={}, name='robot')
logger.write = MagicMock(return_value=datetime.timedelta(microseconds=9721))
bus = BusHandler(logger,
out={'raw':[(robot_bus.queue, 'raw')]},
name='lora')
c = LoRa(bus=bus, config={}) # force autodetection
c.start()
c.bus.queue.put((datetime.timedelta(microseconds=1331), 'raw', b'4|alive\n'))
# c.bus.queue.put((datetime.timedelta(microseconds=29000), 'raw', b'4|alive-9721\n'))
c.bus.queue.put((datetime.timedelta(microseconds=29000), 'raw', b'4|alive-97'))
c.bus.queue.put((datetime.timedelta(microseconds=29200), 'raw', b'21\n'))
c.request_stop()
c.join()
self.assertEqual(c.device_id, 4)
def test_blind_zone(self):
config = {'blind_zone': 10}
logger = MagicMock()
bus = BusHandler(logger, out={'raw': [], 'scan': []}, name='lidar')
lidar = SICKLidar(config, bus=bus)
scan = [123] * 269 + [2]
masked_scan = lidar.apply_mask(scan)
self.assertEqual(masked_scan[-1], 0)
def test_usage(self):
bus = BusHandler(name='app', logger=MagicMock)
app = FollowMe(config={}, bus=bus)
bus.queue.put((0, 'emergency_stop', True))
app.raise_exception_on_stop = True
with self.assertRaises(EmergencyStopException):
app.followme()
def test_publish_status(self):
q = MagicMock()
logger = MagicMock()
logger.write = MagicMock(return_value=135)
bus = BusHandler(logger=logger,
out={
'status': [
(q, 'status'),
],
'can': []
})
spider = Spider(config={}, bus=bus)
spider.can_bridge_initialized = True # skip initialization
self.assertEqual(CAN_packet(0x200, [0, 0x80]), b'@\x02\x00\x80')
bus.queue.put((123, 'raw', b'@\x02\x00\x80'))
bus.shutdown()
spider.run()
q.put.assert_called_once_with((135, 'status', ([0x8000, None])))
def test_publish(self):
logger = MagicMock()
bus = BusHandler(logger)
with self.assertRaises(KeyError):
bus.publish('raw', b'some binary data')
logger = MagicMock()
logger.register = MagicMock(return_value=1)
bus = BusHandler(logger, out={'raw': []})
bus.publish('raw', b'some binary data 2nd try')
logger.write.assert_called_once_with(
1, b'\xc4\x18some binary data 2nd try')
def test_sleep(self):
config = {}
logger = MagicMock()
bus = BusHandler(logger, out={'raw': [], 'scan': []}, name='lidar')
lidar = SICKLidar(config, bus=bus)
self.assertIsNone(lidar.sleep)
config = {"sleep": 0.1}
lidar = SICKLidar(config, bus=bus)
self.assertAlmostEqual(lidar.sleep, 0.1)
def test_two_modules(self):
logger = MagicMock()
handler2 = BusHandler(logger)
handler1 = BusHandler(logger, out={'raw': [(handler2.queue, 42)]})
logger.write = MagicMock(return_value=123)
handler1.publish('raw', b"Hello!")
self.assertEqual(handler2.listen(), (123, 42, b"Hello!"))
def test_sync(self):
q = MagicMock()
logger = MagicMock()
logger.write = MagicMock(return_value=135)
bus = BusHandler(logger=logger,
out={
'can': [],
'encoders': [],
'emergency_stop': [],
'pose2d': [
(q, 'pose2d'),
],
'buttons': []
})
eduro = Eduro(config={}, bus=bus)
sync = CAN_packet(0x80, [])
bus.queue.put((123, 'can', sync))
bus.shutdown()
eduro.run()
q.put.assert_called_once_with((135, 'pose2d', [0, 0, 0]))
def test_mask(self):
config = {'mask': [1, -1]}
logger = MagicMock()
bus = BusHandler(logger, out={'raw': [], 'scan': []}, name='lidar')
lidar = SICKLidar(config, bus=bus)
scan = [123] * 270
masked_scan = lidar.apply_mask(scan)
self.assertEqual(masked_scan[0], 0)
self.assertEqual(scan[1:-1], masked_scan[1:-1])
self.assertEqual(masked_scan[-1], 0)
def test_buttons(self):
# is there a simpler way without starting the Thread??
q = MagicMock()
logger = MagicMock()
logger.write = MagicMock(return_value=42)
bus = BusHandler(logger=logger,
out={
'can': [],
'encoders': [],
'emergency_stop': [],
'pose2d': [],
'buttons': [(q, 'buttons')]
})
eduro = Eduro(config={}, bus=bus)
buttons_msg = CAN_packet(0x28A, [0, 0])
bus.queue.put((42, 'can', buttons_msg))
bus.shutdown()
eduro.run()
q.put.assert_called_once_with((42, 'buttons', {
'blue_selected': True,
'cable_in': False
}))
def test_start_stop(self):
config = {}
logger = MagicMock()
bus = BusHandler(logger,
out={
'orientation': [],
'rotation': []
},
name='imu')
imu = IMU(config, bus=bus)
imu.start()
imu.request_stop()
imu.join()
def test_twoway_communication(self):
with patch('osgar.drivers.logserial.serial.Serial') as mock:
instance = mock.return_value
logger = MagicMock()
bus = BusHandler(logger)
config = {'port':'COM13:', 'speed':4800}
device = LogSerial(config=config, bus=bus)
bus.queue.put((1, 2, b'bin data'))
device.start()
device.request_stop()
device.join()
instance.write.assert_called_once_with(b'bin data')
def test_not_started_dynamic_tcp(self):
with patch('osgar.drivers.logsocket.socket.socket') as mock:
instance = mock.return_value
logger = MagicMock()
bus = BusHandler(logger)
config = {}
device = LogTCPDynamicIP(config=config, bus=bus)
device.start()
time.sleep(0.1)
device.request_stop()
device.join()
instance.connect.assert_not_called()
def test_tcp_send(self):
with patch('osgar.drivers.logsocket.socket.socket') as mock:
instance = mock.return_value
logger = MagicMock()
logger.register = MagicMock(return_value=1)
bus = BusHandler(logger)
config = {'host': '192.168.2.23', 'port': 2111}
device = LogTCP(config=config, bus=bus)
bus.queue.put((1, 'raw', b'bin data'))
device.start()
device.request_stop()
device.join()
instance.send.assert_called_once_with(b'bin data')
def test_encoders_overflow(self):
q = MagicMock()
logger = MagicMock()
logger.write = MagicMock(return_value=22)
bus = BusHandler(logger=logger,
out={'can': [], 'encoders': [(q, 'encoders')], 'emergency_stop': [],
'pose2d': [], 'buttons': []})
eduro = Eduro(config={}, bus=bus)
sync = CAN_packet(0x80, [])
enc_left = CAN_packet(0x181, [0xff, 0xff, 0xff, 0x7f])
bus.queue.put((42, 'can', enc_left))
bus.queue.put((123, 'can', sync))
enc_left = CAN_packet(0x181, [0x01, 0x00, 0x00, 0x80])
bus.queue.put((44, 'can', enc_left))
sync = CAN_packet(0x80, [])
bus.queue.put((123, 'can', sync))
bus.shutdown()
eduro.run()
self.assertEqual(q.put.call_args_list, [call((22, 'encoders', [0, 0])),
call((22, 'encoders', [2, 0]))])
def test_dynamic_tcp(self):
with patch('osgar.drivers.logsocket.socket.socket') as mock:
instance = mock.return_value
logger = MagicMock()
bus = BusHandler(logger)
bus.queue.put((1, 'addr', ['10.1.10.1', 8000]))
config = {}
device = LogTCPDynamicIP(config=config, bus=bus)
device.start()
time.sleep(0.1)
device.request_stop()
device.join()
instance.connect.assert_called_once_with(('10.1.10.1', 8000))
def test_tcp_server(self):
with patch('osgar.drivers.logsocket.socket.socket') as mock:
instance = mock.return_value
instance.accept = MagicMock(return_value=('127.0.0.1', 1234))
instance.recv = MagicMock(return_value=b'some bin data')
logger = MagicMock()
bus = BusHandler(logger)
config = {'host': '192.168.1.2', 'port': 8080}
device = LogTCPServer(config=config, bus=bus)
device.start()
device.request_stop()
device.join()
instance.listen.assert_called_once_with(1)
instance.bind.assert_called_once_with(('192.168.1.2', 8080))
def test_publish(self):
logger = MagicMock()
bus = BusHandler(logger)
with self.assertRaises(KeyError):
bus.publish('raw', b'some binary data')
logger = MagicMock()
logger.register = MagicMock(return_value=1)
bus = BusHandler(logger, out={'raw':[]})
bus.publish('raw', b'some binary data 2nd try')
logger.write.assert_called_once_with(1, b'\xc4\x18some binary data 2nd try')
def test_usage(self):
q = MagicMock()
logger = MagicMock()
logger.write = MagicMock(return_value=135)
bus = BusHandler(logger=logger,
out={
'raw': [(q, 'raw')],
'encoders': [],
'emergency_stop': [],
'pose2d': [],
'buttons': []
})
robot = Cortexpilot(config={}, bus=bus)
robot.start()
robot.request_stop()
robot.join()
# at first request firmware version
q.put.assert_called_once_with(
(135, 'raw', b'\x00\x00\x03\x01\x01\xfb'))
def test_dynamic_tcp_called_twice(self):
with patch('osgar.drivers.logsocket.socket.socket') as mock:
instance = mock.return_value
logger = MagicMock()
bus = BusHandler(logger)
bus.queue.put((1, 'addr', ['10.1.10.1', 8000]))
bus.queue.put((42, 'addr', ['192.168.1.31', 8010]))
config = {}
device = LogTCPDynamicIP(config=config, bus=bus)
device.start()
time.sleep(0.1)
device.request_stop()
device.join()
self.assertEqual(
instance.connect.call_args_list,
[call(('10.1.10.1', 8000)),
call(('192.168.1.31', 8010))])
def test_usage(self):
logger = MagicMock()
bus = BusHandler(logger, out={'cmd_vel':[], 'imu_data':[],
'imu_data_addr':[]})
config = {
'ros_master_uri': 'http://127.0.0.1:11311',
'ros_client_uri': 'http://127.0.0.1:8000',
'topic': '/hello',
'topic_type': 'std_msgs/String',
'subscribe': [
['/imu/data', 'std_msgs/Imu', 'imu_data']
]
}
master = DummyROSMaster(('127.0.0.1', 11311))
proxy = ROSProxy(config=config, bus=bus)
with GlobalExceptionWatcher():
proxy.start()
proxy.request_stop()
proxy.join()
def test_publish_time(self):
logger = MagicMock()
logger.register = MagicMock(return_value=1)
logger.write = MagicMock(return_value=timedelta(123))
bus = BusHandler(logger, out={'stdout':[]})
self.assertEqual(bus.publish('stdout', 'hello world!'), timedelta(123))
def test_publish_serialization(self):
logger = MagicMock()
logger.register = MagicMock(return_value=1)
bus = BusHandler(logger, out={'position':[]})
bus.publish('position', (-123, 456))
logger.write.assert_called_once_with(1, b'\x92\xd0\x85\xcd\x01\xc8')
def test_listen(self):
logger = MagicMock()
handler = BusHandler(logger)
handler.queue.put((1, 2, b"bin data"))
self.assertEqual(handler.listen(), (1, 2, b"bin data"))
def test_shutdown(self):
logger = MagicMock()
handler = BusHandler(logger)
handler.shutdown()
with self.assertRaises(BusShutdownException):
handler.listen()
def test_named_publish(self):
logger = MagicMock()
logger.register = MagicMock(return_value=1)
bus = BusHandler(logger, name='gps_serial', out={'raw':[]})
bus.publish('raw', b'bin data')
logger.write.assert_called_once_with(1, b'\xc4\x08bin data')
def test_alive(self):
logger = MagicMock()
bus = BusHandler(logger, out={})
self.assertTrue(bus.is_alive())
bus.shutdown()
self.assertFalse(bus.is_alive())
def test_report_error(self):
log = MagicMock()
bus = BusHandler(log)
bus.report_error(KeyError(123))
log.write.assert_called_once_with(0, b"{'error': '123'}")
