def __init__(self, device_tty, baud, platform_module=None, platform_args=None):
self.pw_rpc_client = HdlcRpcClient(serial.Serial(device_tty, baud), [PROTO])
self._platform = None
print("Platform args: %s" % platform_args)
print("Platform module: %s" % platform_module)
if platform_module:
m = importlib.import_module(platform_module)
create_platform_method = getattr(m, "create_platform")
self._platform = create_platform_method(platform_args)
def __init__(self, device_tty, baud, platform_module=None, platform_args=None):
ser = serial.Serial(device_tty, baud, timeout=0.01)
self.pw_rpc_client = HdlcRpcClient(lambda: ser.read(4096),
[PROTO], default_channels(ser.write))
self._platform = None
print("Platform args: %s" % platform_args)
print("Platform module: %s" % platform_module)
if platform_module:
m = importlib.import_module(platform_module)
create_platform_method = getattr(m, "create_platform")
self._platform = create_platform_method(platform_args)
def __init__(self, device, protos):
"""
Pigweed Client class containing RPC client initialization and service functions
Create HdlcRpcCLient object and redirect serial communication to it
:param device: test device instance
:param protos: array of RPC protocols
"""
self.device = device
self.device.stop()
self.last_timeout = self.device.serial.get_timeout()
self.device.serial.set_timeout(0.01)
self._pw_rpc_client = HdlcRpcClient(
lambda: self.device.serial.read(4096), protos,
default_channels(self.device.serial.write))
self._rpcs = self._pw_rpc_client.rpcs()
def get_hdlc_rpc_client(device: str, baudrate: int, output: Any, **kwargs):
"""Get the HdlcRpcClient based on arguments."""
serial_device = serial.Serial(device, baudrate, timeout=1)
def read(): return serial_device.read(8192)
write = serial_device.write
return HdlcRpcClient(read, PROTOS, default_channels(write),
lambda data: write_to_file(data, output))
def console(device: str, baudrate: int,
socket_addr: str, output: Any) -> int:
"""Starts an interactive RPC console for HDLC."""
# argparse.FileType doesn't correctly handle '-' for binary files.
if output is sys.stdout:
output = sys.stdout.buffer
logfile = create_temp_log_file()
pw_cli.log.install(logging.INFO, True, False, logfile)
if socket_addr is None:
serial_device = serial.Serial(device, baudrate, timeout=1)
def read(): return serial_device.read(8192)
write = serial_device.write
else:
try:
socket_device = SocketClientImpl(socket_addr)
read = socket_device.read
write = socket_device.write
except ValueError:
_LOG.exception('Failed to initialize socket at %s', socket_addr)
return 1
_start_ipython_terminal(
HdlcRpcClient(read, PROTOS, default_channels(write),
lambda data: write_to_output(data, output)))
return 0
def get_hdlc_rpc_client(device: str, baudrate: int,
proto_globs: Collection[str], socket_addr: str,
**kwargs):
"""Get the HdlcRpcClient based on arguments."""
del kwargs # ignore
if not proto_globs:
proto_globs = ['**/*.proto']
protos = list(_expand_globs(proto_globs))
if not protos:
_LOG.critical('No .proto files were found with %s',
', '.join(proto_globs))
_LOG.critical('At least one .proto file is required')
return 1
_LOG.debug('Found %d .proto files found with %s', len(protos),
', '.join(proto_globs))
# TODO(rgoliver): When pw has a generalized transport for RPC this should
# use it so it isn't specific to HDLC
if socket_addr is None:
serial_device = serial.Serial(device, baudrate, timeout=1)
read = lambda: serial_device.read(8192)
write = serial_device.write
else:
try:
socket_device = SocketClientImpl(socket_addr)
read = socket_device.read
write = socket_device.write
except ValueError:
_LOG.exception('Failed to initialize socket at %s', socket_addr)
return 1
return HdlcRpcClient(read, protos, default_channels(write))
def console(device: str, baudrate: int,
token_databases: Collection[tokens.Database], socket_addr: str,
output: Any, raw_serial: bool) -> int:
"""Starts an interactive RPC console for HDLC."""
# argparse.FileType doesn't correctly handle '-' for binary files.
if output is sys.stdout:
output = sys.stdout.buffer
logfile = create_temp_log_file()
pw_cli.log.install(logging.INFO, True, False, logfile)
serial_impl = SerialWithLogging
if socket_addr is None:
serial_device = serial_impl(device, baudrate, timeout=0)
def read():
return serial_device.read(8192)
write = serial_device.write
else:
try:
socket_device = SocketClientImpl(socket_addr)
read = socket_device.read
write = socket_device.write
except ValueError:
_LOG.exception('Failed to initialize socket at %s', socket_addr)
return 1
callback_client_impl = callback_client.Impl(
default_unary_timeout_s=5.0,
default_stream_timeout_s=None,
)
detokenizer = Detokenizer(tokens.Database.merged(*token_databases),
show_errors=False) if token_databases else None
if raw_serial:
threading.Thread(
target=_read_raw_serial,
daemon=True,
args=(
read,
lambda data: write_to_output(data, output, detokenizer),
)).start()
_start_ipython_raw_terminal()
else:
_start_ipython_hdlc_terminal(
HdlcRpcClient(
read,
PROTOS,
default_channels(write),
lambda data: write_to_output(data, output, detokenizer),
client_impl=callback_client_impl))
return 0
def script(device: str, baud: int) -> None:
# Set up a pw_rpc client that uses HDLC.
ser = serial.Serial(device, baud, timeout=0.01)
client = HdlcRpcClient(lambda: ser.read(4096), [PROTO],
default_channels(ser.write))
# Make a shortcut to the EchoService.
echo_service = client.rpcs().pw.rpc.EchoService
# Call some RPCs and check the results.
status, payload = echo_service.Echo(msg='Hello')
if status.ok():
print('The status was', status)
print('The payload was', payload)
else:
print('Uh oh, this RPC returned', status)
status, payload = echo_service.Echo(msg='Goodbye!')
print('The device says:', payload.msg)
class PigweedDevice:
def __init__(self, device_tty, baud, platform_module=None, platform_args=None):
self.pw_rpc_client = HdlcRpcClient(serial.Serial(device_tty, baud), [PROTO])
self._platform = None
print("Platform args: %s" % platform_args)
print("Platform module: %s" % platform_module)
if platform_module:
m = importlib.import_module(platform_module)
create_platform_method = getattr(m, "create_platform")
self._platform = create_platform_method(platform_args)
def rpcs(self):
return self.pw_rpc_client.rpcs().pw.rpc
@property
def platform(self):
return self._platform
def console(device: str, baudrate: int, proto_globs: Collection[str],
socket_addr: str, output: Any) -> int:
"""Starts an interactive RPC console for HDLC."""
# argparse.FileType doesn't correctly handle '-' for binary files.
if output is sys.stdout:
output = sys.stdout.buffer
if not proto_globs:
proto_globs = ['**/*.proto']
protos = list(_expand_globs(proto_globs))
if not protos:
_LOG.critical('No .proto files were found with %s',
', '.join(proto_globs))
_LOG.critical('At least one .proto file is required')
return 1
_LOG.debug('Found %d .proto files found with %s', len(protos),
', '.join(proto_globs))
if socket_addr is None:
serial_device = serial.Serial(device, baudrate, timeout=1)
read = lambda: serial_device.read(8192)
write = serial_device.write
else:
try:
socket_device = SocketClientImpl(socket_addr)
read = socket_device.read
write = socket_device.write
except ValueError:
_LOG.exception('Failed to initialize socket at %s', socket_addr)
return 1
_start_ipython_terminal(
HdlcRpcClient(read, protos, default_channels(write),
lambda data: write_to_file(data, output)))
return 0
