if __name__ == "__main__":
if len(sys.argv) < 5:
print(
"Usage <address of zenohd router> <rostopic> <rostopic hz> <replay secs>"
)
address = sys.argv[1]
rostopic = sys.argv[2]
sample_rate = int(sys.argv[3])
duration = int(sys.argv[4])
conf = {
'mode': 'client',
'peer': '{}'.format(address),
}
print("Opening Zenoh session...")
zenoh = Zenoh(conf)
print(
"Server connected to Zenoh router {}, publishing on rostopic {}, at rate {}"
.format(address, rostopic, sample_rate))
# Zenoh workspace creation
print("New Zenoh workspace...")
workspace = zenoh.workspace(storage_path)
app = create_app(workspace, rostopic, sample_rate, duration)
app.register_blueprint(route_blueprint)
app.run(host='0.0.0.0', port=5000, debug=True)
# Shutting down Zenoh
zenoh.close()
) # be aware that this can overwrite a smarter model if this application is stopped and restarted
else:
global_model.load_state_dict(torch.load('global.pt'))
else:
torch.save(
global_model.state_dict(), 'global.pt'
) # be aware that this can overwrite a smarter model if this application is stopped and restarted
# initiate logging
zenoh.init_logger()
print("Opening session...")
z = Zenoh(conf)
print("New workspace...")
workspace = z.workspace()
# 0 - Put global model to a path where clients can get it
print("Put global model in /federated/nodes/global")
save_and_put_global_parameters(global_model.state_dict())
# 1 - Listen for notifications
notification_selector = selector + '/notifications'
print("Subscribed to '{}'...".format(notification_selector))
notification_subscriber = workspace.subscribe(notification_selector,
notification_listener)
print("Press q to stop...")
c = '\0'
while c != 'q':
c = sys.stdin.read(1)
def main(stdscr):
# --- Command line argument parsing --- --- --- --- --- ---
parser = argparse.ArgumentParser(prog='zn_sub',
description='zenoh-net sub example')
parser.add_argument('--mode',
'-m',
dest='mode',
choices=['peer', 'client'],
type=str,
help='The zenoh session mode.')
parser.add_argument(
'--peer',
'-e',
dest='peer',
metavar='LOCATOR',
action='append',
type=str,
help='Peer locators used to initiate the zenoh session.')
parser.add_argument('--listener',
'-l',
dest='listener',
metavar='LOCATOR',
action='append',
type=str,
help='Locators to listen on.')
parser.add_argument('--config',
'-c',
dest='config',
metavar='FILE',
type=str,
help='A configuration file.')
parser.add_argument('--cmd_vel',
dest='cmd_vel',
default='/rt/turtle1/cmd_vel',
type=str,
help='The "cmd_vel" ROS2 topic.')
parser.add_argument('--rosout',
dest='rosout',
default='/rt/rosout',
type=str,
help='The "rosout" ROS2 topic.')
parser.add_argument('--angular_scale',
'-a',
dest='angular_scale',
default='2.0',
type=float,
help='The angular scale.')
parser.add_argument('--linear_scale',
'-x',
dest='linear_scale',
default='2.0',
type=float,
help='The linear scale.')
args = parser.parse_args()
conf = zenoh.config_from_file(
args.config) if args.config is not None else {}
if args.mode is not None:
conf["mode"] = args.mode
if args.peer is not None:
conf["peer"] = ",".join(args.peer)
if args.listener is not None:
conf["listener"] = ",".join(args.listener)
cmd_vel = args.cmd_vel
rosout = args.rosout
angular_scale = args.angular_scale
linear_scale = args.linear_scale
# zenoh-net code --- --- --- --- --- --- --- --- --- --- ---
# initiate logging
zenoh.init_logger()
print("Openning session...")
z = Zenoh(conf)
workspace = z.workspace()
def rosout_callback(change):
if change.value is not None:
log = Log.deserialize(change.value.get_content())
print('[{}.{}] [{}]: {}'.format(log.stamp.sec, log.stamp.nanosec,
log.name, log.msg))
print("Subscriber on '{}'...".format(rosout))
sub = workspace.subscribe(rosout, rosout_callback)
def pub_twist(linear, angular):
print("Pub twist: {} - {}".format(linear, angular))
t = Twist(linear=Vector3(x=linear, y=0.0, z=0.0),
angular=Vector3(x=0.0, y=0.0, z=angular))
workspace.put(cmd_vel, t.serialize())
while True:
c = stdscr.getch()
if c == curses.KEY_UP:
pub_twist(1.0 * linear_scale, 0.0)
elif c == curses.KEY_DOWN:
pub_twist(-1.0 * linear_scale, 0.0)
elif c == curses.KEY_LEFT:
pub_twist(0.0, 1.0 * angular_scale)
elif c == curses.KEY_RIGHT:
pub_twist(0.0, -1.0 * angular_scale)
elif c == 27 or c == ord('q'):
break
sub.close()
zenoh.close()
from zenoh import Zenoh
if __name__ == "__main__":
z = Zenoh({})
w = z.workspace('/')
results = w.get('/myhome/kitcken/temp')
key, value = results[0].path, results[0].value
print(' {} : {}'.format(key, value))
class ZenohNative(ServiceABC):
"""
A higher level API providing the same abstractions as the zenoh-net API in a simpler and more data-centric oriented
manner as well as providing all the building blocks to create a distributed storage. The zenoh layer is aware of
the data content and can apply content-based filtering and transcoding.
(source: http://zenoh.io/docs/getting-started/key-concepts/)
Available functionalities:
[1] put : push live data to the matching subscribers and storages. (equivalent of zenoh-net write)
[2] subscribe : subscriber to live data. (equivalent of zenoh-net subscribe)
[3] get : get data from the matching storages and evals. (equivalent of zenoh-net query)
[4] storage : the combination of a zenoh-net subscriber to listen for live data to store and a zenoh-net
queryable to reply to matching get requests.
[5] eval : an entity able to reply to get requests. Typically used to provide data on demand or
build a RPC system. (equivalent of zenoh-net queryable)
Implemented scenarios:
1. Zenoh SUBSCRIBER
Sample input: listener=None, mode='peer', peer=None, selector='/demo2/**'
2. Zenoh PUT
Sample input: listener=None, mode='peer', path='/demo2/example/test', peer=None, value='Hello World'
3. Zenoh GET
Sample input: listener=None, mode='peer', peer=None, selector='/demo/example/**'
"""
class ZenohMode(Enum):
PEER = "peer"
CLIENT = "client"
class SessionType(Enum):
SUBSCRIBER = "SUBSCRIBER"
PUT = "PUT"
GET = "GET"
def __init__(self,
_listener=None,
_mode="peer",
_peer=None,
_selector=None,
_path=None,
_session_type=None):
super().__init__()
self.listener = _listener # Locators to listen on.
self.mode = _mode # The zenoh session mode.
self.peer = _peer # Peer locators used to initiate the zenoh session.
self.selector = _selector # The selection of resources to subscribe.
self.path = _path # The name of the resource to put.
self.session_type = self._get_session_type(
_session_type) # Type of Zenoh connection
# setup configuration
self.conf = {"mode": self.mode}
if self.peer is not None:
self.conf["peer"] = self.peer
if self.listener is not None:
self.conf["listener"] = self.listener
self.workspace = None
self.z_session = None
self.pub = None
self.sub = None
def _get_session_type(self, _type):
if _type.upper() == self.SessionType.PUT.value:
return self.SessionType.PUT.value
elif _type.upper() == self.SessionType.SUBSCRIBER.value:
return self.SessionType.SUBSCRIBER.value
elif _type.upper() == self.SessionType.GET.value:
return self.SessionType.GET.value
else:
return None
def init_connection(self):
# initiate logging
# zenoh.init_logger()
L.warning("[ZENOH] Openning session...")
self.z_session = Zenoh(self.conf)
L.warning("[ZENOH] Create New workspace...")
self.workspace = self.z_session.workspace()
def close_connection(self, _subscriber=None):
self.z_session.close()
L.warning("[ZENOH] `{}` session has been closed".format(
self.session_type))
def register_subscriber(self, listener):
L.warning("[ZENOH] Registering new consumer")
self.sub = self.workspace.subscribe(self.selector, listener)
def register_publisher(self):
pass # nothing to do here
def publish_data(self, val):
L.warning("[ZENOH] Publish data")
self.workspace.put(self.path, val)