def __init__(self, IP = '127.0.0.1' , port = 7000, initial_port_number = 9000): """ Creates a new master object for service discovery Parameters ---------- IP : string IP value of server port : int Port used to connect the socket initial_port_number : int Port numbers will be registered starting from the value of this parameter """ # Start master server try: self.nodes_register = {} self.server = nep.server(IP,port) self.IP = IP self.initial_port_number = initial_port_number # Ports configuration self.current_port = initial_port_number self.topic_register = {} self.threads_id = [] self.brokers = [] msg_type = "json" # Message type to listen. "string" or "dict" node = nep.node("master_node") # Create a new node pub_port = 7777 conf = node.direct(ip = IP, port = pub_port, mode ="one2many") # Select the configuration of the publisher self.master_pub = node.new_pub("master",msg_type,conf) time.sleep(1) self.master_pub.publish(self.topic_register) except Exception as e: print("MASTER ALREADY OPEN") sys.exit(0)
from utils.inference import load_detection_model from utils.preprocessor import preprocess_input import nep import threading import sys import time show_image = 1 try: show_image = int(sys.argv[1]) print("Show image: " + str(show_image)) except: pass node = nep.node('emotion_recognition') sub_image = node.new_sub('robot_image', 'image') sub_position = node.new_sub('face_positions', 'json') pub_emotion = node.new_pub('/blackboard', 'json') myImage = cv2.imread("x.jpg") # Temporal image #classes = ["angry", "fear", "sad", "happy", "surprise", "neutral"] #object_per = sharo.ObjectPerception(node, classes) def thread_function(name): # Get images as soon as possible global myImage, sub_image while True: s, img = sub_image.listen() if s: myImage = cv2.resize(img, (640, 480), interpolation=cv2.INTER_AREA)
import nep import time import sys msg_type = "string" # Message type to listen. node = nep.node("publisher_sample","ROS2") # Create a new node pub = node.new_pub("pub_sub_test",msg_type) # Set the topic and the configuration of the publisher # Publish a message each second while True: msg = "hello world" print ("sending: " + msg) pub.publish(msg) time.sleep(1)
robot_name = robot_info["name"] robot_ip = robot_info["ip"] robot_port = robot_info["port"] middleware = robot_info["middleware"] print("Robot name:" + str(robot_name)) print("Robot IP to connect:" + str(robot_ip)) print("Robot PORT to connect:" + str(robot_port)) print("Middleware:" + str(middleware)) except: pass behavior = nep_aldebaran.BehaviorManager(robot_ip, robot_port) behavior.onStop() autonomus = nep_aldebaran.AutonomusLife(robot_ip, robot_port) autonomus.onStop() print("Robot ready") name_ = "reset_robot" node = nep.node(name_) pub = node.new_pub("/set_speech", "json") time.sleep(1) pub.publish({"action": "stop"}) track = nep_aldebaran.Tracking(robot_ip, robot_port) track.onStop() time.sleep(1) print("Robot reset complete")
print('I connected on ' + ip_port) @sioClient.on('data') def on_message(data): print('I received a message!'+ data) server_data = data if __name__ == "__main__": # ip = raw_input("Enter your ip : ") # port = raw_input("Enter your port : ") # sio.connect('http://' + ip + ':' + port) sioClient.connect(ip_port) node = nep.node('python_client', 'ROS') pub = node.new_pub('python_client',msg_type = "string") while True: # Here is your code ... #msg = {'message':'hello'} # An example of message msg = "hello" pub.publish(msg) # Send message time.sleep(1)
import nep import time node = nep.node("surveyor_test") sur = node.new_surveyor('surveyor_sample', timeout=1000) while True: x = {"node": "action"} print("data to send:" + str(x)) sur.send_json(x) s, msg = sur.listen_json() if s: print("data read" + str(msg)) else: print("respondent not connected") time.sleep(1)
import nep import time node = nep.node("client_test") client = node.new_client("client_server_sample") while True: msg = {"message":"client request"} # Message to send as request client.send_info(msg) # Send request print (client.listen_info()) # Wait for server response time.sleep(1) # Wait one second
ip = sys.argv[1] print ("resolution: " + sys.argv[2]) resolution = int(sys.argv[2]) except: pass ### Image format ##k960p = 3 # 1280*960 ##k4VGA = 3 # 1280*960 ##kVGA = 2 # 640*480 ##kQVGA = 1 # 320*240 ##kQQVGA = 0 # 160*120 video_service = ALProxy("ALVideoDevice", ip, 9559) node = nep.node("pepper_image") pub = node.new_pub("robot_image", "image") #video_service = session.service("ALVideoDevice") #colorSpace = vision_definitions.kRGBColorSpace colorSpace = 11 #colorSpace = vision_definitions.kBGRColorSpace #colorSpace = vision_definitions.kRGBColorSpace ##img.header.frame_id = self.frame_id ##img.height = image[1] ##img.width = image[0] ##nbLayers = image[2] ##if image[3] == kYUVColorSpace: ## encoding = "mono8"
# This example does not need rosbridge, it directly publish to rize # Add these lines to your python script import nep import time # (For ROS 1.0 use) node = nep.node('python_sender', 'ROS') # (For ROS 2.0 use) #node = nep.node('python_sender','ROS2') pub = node.new_pub('/blackboard', 'json') # Dummy perceptual function def isHeadTouched(): return true # Publish the current state when while True: # Here your code that recognize something # Example: head_touched = isHeadTouched() if head_touched: msg = {'primitive': 'touched', 'input': {"head": 1}, "robot": "ROS"} pub.publish(msg) print("send perception ...") time.sleep(10) # In {'primitive':'touched', 'input':{"head":1}, "robot":"ROS"} -- {"head":1} means 100% probability that is touched
import nep # Import nep library node = nep.node("server_test") server = node.new_server("client_server_sample") while True: msg = {"message": "hello"} # Message to send as response request = server.listen_info() # Wait for client request server.send_info(msg) # Send server response print(request)
flip = 0 try: print(sys.argv[1]) id_ = int(sys.argv[1]) print("Camera id:" + str(id_)) x_resolution = int(sys.argv[2]) print("X:" + str(x_resolution)) y_resolution = int(sys.argv[3]) print("Y:" + str(y_resolution)) flip = int(sys.argv[4]) print("flip:" + str(flip)) except: pass node = nep.node('usb_camera') pub_image = node.new_pub('robot_image', 'image') video = cv2.VideoCapture(id_) video.set(cv2.CAP_PROP_FRAME_WIDTH, x_resolution) video.set(cv2.CAP_PROP_FRAME_HEIGHT, y_resolution) print('Start Video recording!') while True: success, frame = video.read() # Display the resulting image if (x_resolution > 640): dim = (640, 480) frame = cv2.resize(frame, dim, interpolation=cv2.INTER_AREA) if (flip == 1):
import nep msg_type = "json" # Message type to listen. "string" or "json" node = nep.node("subscriber_sample", "nanomsg") # Create a new node conf = node.broker( mode="one2many") # Select the configuration of the subscriber sub = node.new_sub( "pub_sub_test_nn", msg_type, conf) # Set the topic and the configuration of the subscriber while True: s, msg = sub.listen() # Non blocking socket if s: # Info avaliable only if s == True print(str(msg))
import nep import time import sys msg_type = "json" # Message type to listen. "string" or "json" node = nep.node("publisher_sample", "nanomsg") # Create a new node conf = node.broker(mode = "one2many") # Select the configuration of the publisher pub = node.new_pub("pub_sub_test_nn",msg_type,conf) # Set the topic and the configuration of the publisher # Publish a message each second while True: # --- String example --- if msg_type == "string": msg = "hello world" print ("sending: " + msg) pub.publish(msg) time.sleep(1) # --- JSON example --- if msg_type == "json": msg = data = {"node":"perception", "primitive":"speech", "input":"add", "robot":"pepper", "parameters":"0"} print ("sending: " + str(msg)) pub.publish(msg) time.sleep(1)
else: inpWidth = 300 #Width of network's input image inpHeight = 300 #Height of network's input image classesFile = path_models + "coco_ms.names" classes = None with open(classesFile, 'rt') as f: classes = f.read().rstrip('\n').split('\n') print(classes) # Lock primitive for securely accessing a shared variable lock = threading.Lock() # ---------- Nep ----------------- node = nep.node("object_recognition") sub_img = node.new_sub("robot_image", "image") # Set the topic and the configuration object_per = sharo.ObjectPerception(node, classes) print("usb source") pub_image = node.new_pub('robot_image_recognition', 'image') myImage = cv2.imread("x.jpg") # Temporal image def thread_function(name): # Get images as soon as possible global myImage while True: s, img = sub_img.listen() if s: lock.acquire()
import nep import time node = nep.node('sender') conf = node.direct(ip = '127.0.0.1', port = 3000, mode ='one2many') pub = node.new_pub('test_subcriber','json',conf) while True: # Here is your code ... msg = {'message':'hello'} # An example of message pub.publish(msg) # Send message time.sleep(.01)
# This example does not need rosbridge, it directly publish to rize # Add these lines to your python script (Python 2 or 3 is ok) import nep import time node = nep.node('python_sender') pub = node.new_pub('/blackboard','json') # Dummy perceptual function def isHeadTouched(): return True # Publish the current state when while True: # Here your code that recognize something # Example: head_touched = isHeadTouched() if head_touched: msg = {'primitive':'touched', 'input':{"head":1}, "robot":"ROS"} pub.publish(msg) print("send perception ...") time.sleep(10) # In {'primitive':'touched', 'input':{"head":1}, "robot":"ROS"} -- {"head":1} means 100% probability that is touched
import nep sub_type = "normal" # Type of subscriber. "callback" or "normal" msg_type = "json" # Message type to listen. "string" or "dict" node = nep.node("subscriber_sample") # Create a new node conf = node.direct(ip = "127.0.0.1", port = 3000, mode ="one2many") # Select the configuration of the subscriber def callback(msg): print ("Callback get") print (msg) if sub_type == "normal": # Listen info inside a while loop sub = node.new_sub("test_subcriber", msg_type, conf) while True: s, msg = sub.listen() # Non blocking socket if s: # Info avaliable only if s == True print(msg) elif sub_type == "callback": # Listen info inside a event loop sub = node.new_callback("test_subcriber", msg_type , callback, conf) node.spin() pass
import numpy as np import os, sys import pickle import nep import threading import sharo show_image = 1 try: print (sys.argv[1]) show_image = int(sys.argv[1]) print ("Show image: " + show_image) except: pass node = nep.node('face_detection') sub_image = node.new_sub('robot_image', 'image') pub_position = node.new_pub('face_positions', 'json') perception_face = sharo.BooleanPerception(node, "human_detected", "value", 1, 3) # --------------- Sharo ------------------ frame = "" bounding_boxes = "" def thread_function(name): global sub_image, frame while True: s, img = sub_image.listen() if s: frame = cv2.resize(img, (640,480), interpolation = cv2.INTER_AREA)