class ROSCloudSubBridge(object): def __init__(self, ip, port, local_topic_name, remote_topic_name, message_type): self._ip = ip self._port = port self._local_topic_name = local_topic_name self._remote_topic_name = remote_topic_name self._message_type = message_type self._ros_client= Ros(self._ip,self._port) self._rosPub = None # Should be specified by the automation engine self._listener = None self._logger = logging.getLogger(self.__class__.__name__) self._logger.setLevel(logging.DEBUG) def _run_topic_pubsub(self): try: self._listener = Topic(self._ros_client, self._remote_topic_name, self._message_type) self._listener2= Topic(self._ros_client, self._remote_topic_name, self._message_type) rospy.init_node('cloudsub', anonymous=True) global my my=rospy.get_time() self._ros_client.on_ready(self._start_receiving, run_in_thread=True) self._ros_client.run_event_loop() except: self._logger.exception("Fatal error in constructor") def _receive_message(self,message): global my rospy.loginfo(rospy.get_caller_id() + " I heard a message of %s",self._message_type) rospy.loginfo(rospy.get_caller_id() + " Time from previous message %s",(rospy.get_time()-my) )#edw mou leei unicode type my=rospy.get_time() try: msg=Image() msg.header.seq=message['header']['seq'] msg.header.stamp.secs=message['header']['stamp']['secs'] msg.header.stamp.nsecs=message['header']['stamp']['nsecs'] msg.header.frame_id=message['header']['frame_id'] msg.height=message['height'] msg.width=message['width'] msg.encoding=str(message['encoding']) msg.is_bigendian=message['is_bigendian'] msg.step=message['step'] msg.data=message['data'].decode('base64') self._rosPub=rospy.Publisher(self._local_topic_name, Image, queue_size=10) #message type is String instead of msg_stds/String self._rosPub.publish(msg) except: print('Error') def _start_receiving(self): self._listener.subscribe(self._receive_message) def start(self): signal.signal(signal.SIGINT, lambda *x: self.stop()) self._run_topic_pubsub() def stop(self): if self._ros_client is not None: self._ros_client.terminate()
class ROSCloudSubBridge(object): def __init__(self, ip, port, local_topic_name, remote_topic_name, message_type): self._ip = ip self._port = port self._local_topic_name = local_topic_name self._remote_topic_name = remote_topic_name self._message_type = message_type self._ros_client= Ros(self._ip,self._port) self._rosPub = None # Should be specified by the automation engine self._listener = None # Should be specified by the automation engine self._logger = logging.getLogger(self.__class__.__name__) self._logger.setLevel(logging.DEBUG) self.br =tf2_ros.StaticTransformBroadcaster() self.t = [] def _run_topic_pubsub(self): try: self._listener = Topic(self._ros_client, self._remote_topic_name, self._message_type) rospy.init_node('cloudsub', anonymous=True) global my my=rospy.get_time() self._ros_client.on_ready(self._start_receiving, run_in_thread=True) self._ros_client.run_event_loop() except: self._logger.exception("Fatal error in constructor") def _receive_message(self,message): global my rospy.loginfo(rospy.get_caller_id() + " Message type %s ",self._message_type) rospy.loginfo(rospy.get_caller_id() + " Time from previous message %s ",(rospy.get_time()-my)) my=rospy.get_time() for i in range(len(message['transforms'])): self.t.append(TransformStamped()) self.t[-1].header.stamp = rospy.Time.now() self.t[-1].header.frame_id = message['transforms'][i]['header']['frame_id'] self.t[-1].child_frame_id = message['transforms'][i]['child_frame_id'] self.t[-1].transform.translation.x = message['transforms'][i]['transform']['translation']['x'] self.t[-1].transform.translation.y = message['transforms'][i]['transform']['translation']['y'] self.t[-1].transform.translation.z = message['transforms'][i]['transform']['translation']['z'] self.t[-1].transform.rotation.x = message['transforms'][i]['transform']['rotation']['x'] self.t[-1].transform.rotation.y = message['transforms'][i]['transform']['rotation']['y'] self.t[-1].transform.rotation.z = message['transforms'][i]['transform']['rotation']['z'] self.t[-1].transform.rotation.w = message['transforms'][i]['transform']['rotation']['w'] self.br.sendTransform(self.t) def _start_receiving(self): self._listener.subscribe(self._receive_message) def start(self): signal.signal(signal.SIGINT, lambda *x: self.stop()) self._run_topic_pubsub() def stop(self): if self._ros_client is not None: self._ros_client.terminate()
def run_topic_pubsub(): context = {'counter': 0} ros_client = Ros('127.0.0.1', 9090) listener = Topic(ros_client, '/chatter', 'std_msgs/String') publisher = Topic(ros_client, '/chatter', 'std_msgs/String') def receive_message(message): context['counter'] += 1 assert message['data'] == 'hello world', 'Unexpected message content' if context['counter'] == 3: listener.unsubscribe() # Give it a bit of time, just to make sure that unsubscribe # really unsubscribed and counter stays at the asserted value ros_client.call_later(2, ros_client.terminate) def start_sending(): while True: if not ros_client.is_connected: break publisher.publish(Message({'data': 'hello world'})) time.sleep(0.1) publisher.unadvertise() def start_receiving(): listener.subscribe(receive_message) ros_client.on_ready(start_receiving, run_in_thread=True) ros_client.on_ready(start_sending, run_in_thread=True) ros_client.run_forever() assert context[ 'counter'] >= 3, 'Expected at least 3 messages but got ' + str( context['counter'])
class ROSCloudSubBridge(object): def __init__(self, ip, port, local_topic_name, remote_topic_name, message_type, file): self._ip = ip self._port = port self._local_topic_name = local_topic_name self._remote_topic_name = remote_topic_name self._message_type = message_type self._ros_client = Ros(self._ip, self._port) self._rosPub = None # Should be specified by the automation engine self._listener = None # Should be specified by the automation engine self._service = None self._logger = logging.getLogger(self.__class__.__name__) self._logger.setLevel(logging.DEBUG) self._file = file def _run_topic_pubsub(self): try: self._listener = Topic(self._ros_client, self._remote_topic_name, self._message_type) rospy.init_node('cloudsub', anonymous=True) self._ros_client.send_on_ready(Message(self._file)) global my my = rospy.get_time() self._ros_client.on_ready(self._start_receiving, run_in_thread=True) self._ros_client.run_event_loop() except: self._logger.exception("Fatal error in constructor") def _receive_message(self, message): global my rospy.loginfo(rospy.get_caller_id() + " Message type %s ", self._message_type) rospy.loginfo( rospy.get_caller_id() + " Time from previous message %s ", (rospy.get_time() - my)) my = rospy.get_time() try: msg = Clock() msg.clock.secs = message['clock']['secs'] msg.clock.nsecs = message['clock']['nsecs'] self._rosPub = rospy.Publisher( self._local_topic_name, Clock, queue_size=10 ) #message type is String instead of msg_stds/String self._rosPub.publish(msg) except: print('Error') def _start_receiving(self): self._listener.subscribe(self._receive_message) def start(self): signal.signal(signal.SIGINT, lambda *x: self.stop()) self._run_topic_pubsub() def stop(self): if self._ros_client is not None: self._ros_client.terminate()
def run_rosapi_topics(): ros_client = Ros('127.0.0.1', 9090) def callback(topic_list): assert ('/rosout' in topic_list['topics']) ros_client.terminate() def get_topics(): ros_client.get_topics(callback) ros_client.on_ready(get_topics) ros_client.run_event_loop()
def run_topic_pubsub(): context = {'counter': 0} ros_client = Ros('192.168.1.106', 9090) listener = Topic(ros_client, '/chatter', 'std_msgs/String') publisher = Topic(ros_client, '/chatter', 'std_msgs/String') def receive_message(message): print("============================") context['counter'] += 1 assert message['data'] == 'hello world', 'Unexpected message content' if context['counter'] == 3: listener.unsubscribe() # Give it a bit of time, just to make sure that unsubscribe # really unsubscribed and counter stays at the asserted value ros_client.call_later(2, ros_client.terminate) # def callback(topic_list): # print(topic_list) # assert('/rosout' in topic_list['topics']) # time.sleep(1) # ros_client.terminate() def start_sending(): while True: print("---------------------") if not ros_client.is_connected: break publisher.publish(Message({'data': 'hello world'})) print(listener.is_subscribed) time.sleep(0.1) ros_client.terminate break # ros_client.get_topics(callback) publisher.unadvertise() def start_receiving(): listener.subscribe(receive_message) ros_client.on_ready(start_receiving, run_in_thread=True) ros_client.on_ready(start_sending, run_in_thread=True) ros_client.run_forever() assert context[ 'counter'] >= 3, 'Expected at least 3 messages but got ' + str( context['counter'])
def run_rosapi_topics(*args, **kwargs): ros_client = Ros(*args, **kwargs) def callback(topic_list): print(topic_list) assert('/rosout' in topic_list['topics']) time.sleep(1) ros_client.terminate() def get_topics(): ros_client.get_topics(callback) ros_client.on_ready(get_topics) ros_client.run_forever()
class rosbridge_client: def __init__(self): self.ros_client = Ros('127.0.0.1', 9090) print("wait for server") self.publisher = Topic(self.ros_client, '/cmd_vel', 'geometry_msgs/Twist') self.listener = Topic(self.ros_client, '/odom', 'nav_msgs/Odometry') self.listener.subscribe(self.callback) self.ros_client.on_ready(self.start_thread, run_in_thread=True) self.ros_client.run_forever() def callback(self, message): x = message["pose"]["pose"]["position"]["x"] y = message["pose"]["pose"]["position"]["y"] print(x, y) def start_thread(self): while True: if self.ros_client.is_connected: self.publisher.publish( Message({ 'linear': { 'x': 0.5, 'y': 0, 'z': 0 }, 'angular': { 'x': 0, 'y': 0, 'z': 0.5 } })) else: print("Disconnect") break time.sleep(1.0)
class ROSCloudSubBridge(object): def __init__(self, ip, port, local_topic_name, remote_topic_name, message_type): self._ip = ip self._port = port self._local_topic_name = local_topic_name self._remote_topic_name = remote_topic_name self._message_type = message_type self._ros_client = Ros(self._ip, self._port) self._rosPub = None # Should be specified by the automation engine self._listener = None # Should be specified by the automation engine # self._2listener = None # Should be specified by the automation engine self._logger = logging.getLogger(self.__class__.__name__) self._logger.setLevel(logging.DEBUG) def _run_topic_pubsub(self): try: self._listener = Topic(self._ros_client, self._remote_topic_name, self._message_type) # self._2listener = Topic(self._ros_client, self._remote_topic_name, self._message_type) rospy.init_node('cloudsub', anonymous=True) global my # global my2 # my2=rospy.get_time() my = rospy.get_time() self._ros_client.on_ready(self._start_receiving, run_in_thread=True) self._ros_client.run_event_loop() except: self._logger.exception("Fatal error in constructor") def _receive_message(self, message): global my rospy.loginfo(rospy.get_caller_id() + " Message type %s ", self._message_type) rospy.loginfo( rospy.get_caller_id() + " Time from previous message %s ", (rospy.get_time() - my)) my = rospy.get_time() try: msg = Status() msg.header.seq = message['header']['seq'] msg.header.stamp.secs = message['header']['stamp']['secs'] msg.header.stamp.nsecs = message['header']['stamp']['nsecs'] msg.header.frame_id = message['header']['frame_id'] msg.id = message['id'] msg.active = message['active'] msg.heartbeat_timeout = message['heartbeat_timeout'] msg.heartbeat_period = message['heartbeat_period'] msg.instance_id = message['instance_id'] # for i in range(0,8): # msg.orientation_covariance[i]=message['orientation_covariance'][i] # msg.angular_velocity_covariance[i]=message['angular_velocity_covariance'][i] # msg.linear_acceleration_covariance[i]=message['linear_acceleration_covariance'][i] self._rosPub = rospy.Publisher(self._local_topic_name, Status, queue_size=10) self._rosPub.publish(msg) except: print('Error') # def _2receive_message(self,message): # global my2 # rospy.loginfo(rospy.get_caller_id() + "I heard a message %s",(rospy.get_time()-my2)) # my2=rospy.get_time() # try: # msg=Clock() # msg.clock.secs=message['clock']['secs'] # msg.clock.nsecs=message['clock']['nsecs'] # self._rosPub=rospy.Publisher('/test/clock2', Clock, queue_size=10) #message type $ # self._rosPub.publish(msg) # except: # print('Error') def _start_receiving(self): self._listener.subscribe(self._receive_message) # self._listener2.subscribe(self._2receive_message) def start(self): signal.signal(signal.SIGINT, lambda *x: self.stop()) self._run_topic_pubsub() def stop(self): if self._ros_client is not None: self._ros_client.terminate()
class ROSCloudSubBridge(object): def __init__(self, ip, port, local_topic_name, remote_topic_name, message_type): self._ip = ip self._port = port self._local_topic_name = local_topic_name self._remote_topic_name = remote_topic_name self._message_type = message_type self._ros_client= Ros(self._ip,self._port) self._rosPub = None # Should be specified by the automation engine self._listener = None # Should be specified by the automation engine # self._2listener = None # Should be specified by the automation engine self._logger = logging.getLogger(self.__class__.__name__) self._logger.setLevel(logging.DEBUG) def _run_topic_pubsub(self): try: self._listener = Topic(self._ros_client, self._remote_topic_name, self._message_type) # self._2listener = Topic(self._ros_client, self._remote_topic_name, self._message_type) rospy.init_node('cloudsub', anonymous=True) global my # global my2 # my2=rospy.get_time() my=rospy.get_time() self._ros_client.on_ready(self._start_receiving, run_in_thread=True) self._ros_client.run_event_loop() except: self._logger.exception("Fatal error in constructor") def _receive_message(self,message): global my rospy.loginfo(rospy.get_caller_id() + " Message type %s ",self._message_type) rospy.loginfo(rospy.get_caller_id() + " Time from previous message %s ",(rospy.get_time()-my)) my=rospy.get_time() try: msg=TFMessage() msg1=TransformStamped() list_msg=[] for i in range(len(message['transforms'])) : msg1.header.seq=message['transforms'][i]['header']['seq'] msg1.header.stamp.secs=message['transforms'][i]['header']['stamp']['secs'] msg1.header.stamp.nsecs=message['transforms'][i]['header']['stamp']['nsecs'] msg1.header.frame_id=message['transforms'][i]['header']['frame_id'] msg1.child_frame_id=message['transforms'][i]['child_frame_id'] msg1.transform.translation.x=message['transforms'][i]['transform']['translation']['x'] msg1.transform.translation.y=message['transforms'][i]['transform']['translation']['y'] msg1.transform.translation.z=message['transforms'][i]['transform']['translation']['z'] msg1.transform.rotation.x=message['transforms'][i]['transform']['rotation']['x'] msg1.transform.rotation.y=message['transforms'][i]['transform']['rotation']['y'] msg1.transform.rotation.z=message['transforms'][i]['transform']['rotation']['z'] msg1.transform.rotation.w=message['transforms'][i]['transform']['rotation']['w'] list_msg.append(msg1) msg=TFMessage(list_msg) self._rosPub=rospy.Publisher(self._local_topic_name, TFMessage, queue_size=10) self._rosPub.publish(msg) except: print('Error') def _start_receiving(self): self._listener.subscribe(self._receive_message) # self._listener2.subscribe(self._2receive_message) def start(self): signal.signal(signal.SIGINT, lambda *x: self.stop()) self._run_topic_pubsub() def stop(self): if self._ros_client is not None: self._ros_client.terminate()
class ROSCloudSubBridge(object): def __init__(self, ip, port, local_topic_name, remote_topic_name, message_type): self._ip = ip self._port = port self._local_topic_name = local_topic_name self._remote_topic_name = remote_topic_name self._message_type = message_type self._ros_client = Ros(self._ip, self._port) self._rosPub = None # Should be specified by the automation engine self._listener = None # Should be specified by the automation engine self._logger = logging.getLogger(self.__class__.__name__) self._logger.setLevel(logging.DEBUG) def _run_topic_pubsub(self): try: self._listener = Topic(self._ros_client, self._remote_topic_name, self._message_type) rospy.init_node('cloudsub', anonymous=True) global my my = rospy.get_time() self._ros_client.on_ready(self._start_receiving, run_in_thread=True) self._ros_client.run_event_loop() except: self._logger.exception("Fatal error in constructor") def _receive_message(self, message): global my rospy.loginfo(rospy.get_caller_id() + " Message type %s ", self._message_type) rospy.loginfo( rospy.get_caller_id() + " Time from previous message %s ", (rospy.get_time() - my)) my = rospy.get_time() # try: msg = OccupancyGrid() msg.header.seq = message['header']['seq'] msg.header.stamp = rospy.Time.now( ) #.secs=message['header']['stamp']['secs'] msg.header.frame_id = message['header']['frame_id'] #type unicode msg.info.map_load_time.secs = message['info']['map_load_time']['secs'] msg.info.map_load_time.nsecs = message['info']['map_load_time'][ 'nsecs'] msg.info.resolution = message['info']['resolution'] msg.info.width = message['info']['width'] msg.info.height = message['info']['height'] msg.info.origin.position.x = message['info']['origin']['position']['x'] msg.info.origin.position.y = message['info']['origin']['position']['y'] msg.info.origin.position.z = message['info']['origin']['position']['z'] msg.info.origin.orientation.x = message['info']['origin'][ 'orientation']['x'] msg.info.origin.orientation.y = message['info']['origin'][ 'orientation']['y'] msg.info.origin.orientation.z = message['info']['origin'][ 'orientation']['z'] msg.info.origin.orientation.w = message['info']['origin'][ 'orientation']['w'] msg.data = message['data'] # for i in range(len(message['data'])): # print(i) # msg.data[i]=message['data'][i] self._rosPub = rospy.Publisher(self._local_topic_name, OccupancyGrid, queue_size=10) self._rosPub.publish(msg) # except: # print('Error') def _start_receiving(self): self._listener.subscribe(self._receive_message) def start(self): signal.signal(signal.SIGINT, lambda *x: self.stop()) self._run_topic_pubsub() def stop(self): if self._ros_client is not None: self._ros_client.terminate()
class Muse_app: def __init__(self): self.client = mqtt.Client() self.client2 = mqtt.Client() self.ros_client = Ros(host='10.205.240.34', port=9090) self.publisher = Topic(self.ros_client, '/chatter', 'std_msgs/String') self.muse_left = "DC11" self.muse_right = "C00E" self.status_left = False self.status_right = False self.action_mode = 0 self.client.on_connect = self.on_connect self.client.on_message = self.on_message self.client.connect("localhost", 1883, 60) t = threading.Thread(target=self.worker) t.start() self.client2.on_connect = self.on_connect2 self.client2.on_message = self.on_message self.client2.connect("localhost", 1883, 60) t2 = threading.Thread(target=self.worker2) t2.start() self.ros_client.on_ready(self.subscribing, run_in_thread=True) t3 = threading.Thread(target=self.worker3) t3.start() while True: pass def on_connect(self, client, userdata, flags, rc): print("Connected with result code "+str(rc)) # Subscribing in on_connect() means that if we lose the connection and # reconnect then subscriptions will be renewed. self.client.subscribe("topic/" + self.muse_left) #self.client.subscribe("topic/test") def on_connect2(self, client, userdata, flags, rc): print("Connected with result code "+str(rc)) # Subscribing in on_connect() means that if we lose the connection and # reconnect then subscriptions will be renewed. self.client2.subscribe("topic/" + self.muse_right) def worker(self): self.client.loop_forever() return def worker2(self): self.client2.loop_forever() return def on_message(self, client, userdata, message): print("message received " ,str(message.payload.decode("utf-8"))) print("message topic=",message.topic) if message.topic == "topic/" + self.muse_left: if(message.payload.decode("utf-8") == '0'): self.status_left = False elif(message.payload.decode("utf-8") == '1'): self.status_left = True print("left = " , self.status_left) if message.topic == "topic/" + self.muse_right: if(message.payload.decode("utf-8") == '0'): self.status_right = False elif(message.payload.decode("utf-8") == '1'): self.status_right = True print("right = " , self.status_right) # print("message qos=",message.qos) # print("message retain flag=",message.retain) def subscribing(self): print("subscribe to Ros..") self.publisher.subscribe(self.receive_message) def uninitialize(self): # nop return def receive_message(self, message): # context['counter'] += 1 print('Receive data from Ros, ' , message['data']) #assert message['data'] == 'hello world', 'Unexpected message content' if(message['data'] == "action"): self.client.publish("topic/parameters", 'action') time.sleep(3) print("lastest status from left = " , self.status_left) print("lastest status from right = " , self.status_right) if self.status_left and not self.status_right: ##======================TURN LEFT self.action_mode = 1 elif not self.status_left and self.status_right: ##======================TURN RIGHT self.action_mode = 2 elif not self.status_left and not self.status_right: ##======================MOVE FORWARD self.action_mode = 3 elif self.status_left and self.status_right: ##======================MOVE BACKWARD self.action_mode = 4 print("summary action mode = ", str(self.action_mode)) self.client.publish("topic/parameters", 'wait') isConnected = self.ros_client.is_connected print("isConnected = ", isConnected) if(isConnected): self.publisher.publish(Message({'data': str(self.action_mode)})) def worker3(self): self.ros_client.run_forever()
class ROSCloudSubBridge(object): def __init__(self, ip, port, local_topic_name, remote_topic_name, message_type): self._ip = ip self._port = port self._local_topic_name = local_topic_name self._remote_topic_name = remote_topic_name self._message_type = message_type self._ros_client= Ros(self._ip,self._port) self._rosPub = None # Should be specified by the automation engine self._listener = None # Should be specified by the automation engine self._logger = logging.getLogger(self.__class__.__name__) self._logger.setLevel(logging.DEBUG) def _run_topic_pubsub(self): try: self._listener = Topic(self._ros_client, self._remote_topic_name, self._message_type) rospy.init_node('cloudsub', anonymous=True) global my my=rospy.get_time() self._ros_client.on_ready(self._start_receiving, run_in_thread=True) self._ros_client.run_event_loop() except: self._logger.exception("Fatal error in constructor") def _receive_message(self,message): global my rospy.loginfo(rospy.get_caller_id() + " Message type %s ",self._message_type) rospy.loginfo(rospy.get_caller_id() + " Time from previous message %s ",(rospy.get_time()-my)) my=rospy.get_time() try: msg=LaserScan() msg.header.seq=message['header']['seq'] msg.header.stamp.secs=message['header']['stamp']['secs'] msg.header.stamp.nsecs=message['header']['stamp']['nsecs'] msg.header.frame_id=message['header']['frame_id'] msg.angle_min=message['angle_min'] msg.angle_max=message['angle_max'] msg.angle_increment=message['angle_increment'] msg.time_increment=message['time_increment'] msg.scan_time=message['scan_time'] msg.range_min=message['range_min'] msg.range_max=message['range_max'] ranges_list=[] intensities_list=[] for i in range(len(message['ranges'])): ranges_list.append(float) if message['ranges'][i]==None: ranges_list[i]=float('NaN') else: ranges_list[i]=message['ranges'][i] for i in range(len(message['intensities'])): intensities_list.append(float) if message['intensities'][i]==None: intensities_list[i]=float('NaN') else: intensities_list[i]=message['intensities'][i] msg.ranges=ranges_list msg.intensities=intensities_list self._rosPub=rospy.Publisher(self._local_topic_name, LaserScan, queue_size=10) self._rosPub.publish(msg) except: print('Error') def _start_receiving(self): self._listener.subscribe(self._receive_message) def start(self): signal.signal(signal.SIGINT, lambda *x: self.stop()) self._run_topic_pubsub() def stop(self): if self._ros_client is not None: self._ros_client.terminate()
class MyOVBox(OVBox): def __init__(self): OVBox.__init__(self) self.signalHeader = None self.ros_client = Ros(host='10.204.231.147', port=9090) #self.listener = Topic(self.ros_client, '/chatter', 'std_msgs/String') self.publisher = Topic(self.ros_client, '/chatter', 'std_msgs/String') self.ros_client.on_ready(self.subscribing, run_in_thread=True) self.phase = 0 self.parameters = { "count": "4", "scenario": "4", "gender": "Male", "age": "25", "subjectno": "55", "phase": 5, "type": 2 } # ros_client.on_ready(start_receiving, run_in_thread=True) def initialize(self): self.counter = 0 t = threading.Thread(target=self.worker) t.start() s = threading.Thread(target=self.workerMQTT) s.start() # self.ros_client.run_forever() return def on_connect(self, client, userdata, flags, rc): print("Connected with result code " + str(rc)) # Subscribing in on_connect() means that if we lose the connection and # reconnect then subscriptions will be renewed. self.client.subscribe("topic/parameters") # The callback for when a PUBLISH message is received from the server. def on_message(self, client, userdata, msg): #print(msg.topic+" "+str(msg.payload)) parameters = msg.payload print("parameters = ", parameters) self.parameters = json.loads(parameters) self.phase = int(self.parameters.get('phase')) print("phase = ", self.phase) def worker(self): self.ros_client.run_forever() def workerMQTT(self): self.client = mqtt.Client() self.client.on_connect = self.on_connect self.client.on_message = self.on_message self.client.connect("localhost", 1883, 60) # Blocking call that processes network traffic, dispatches callbacks and # handles reconnecting. # Other loop*() functions are available that give a threaded interface and a # manual interface. self.client.loop_forever() def process(self): self.counter += 1 for chunkIndex in range(len(self.input[0])): if (type(self.input[0][chunkIndex]) == OVSignalHeader): self.signalHeader = self.input[0].pop() outputHeader = OVSignalHeader( self.signalHeader.startTime, self.signalHeader.endTime, [1, self.signalHeader.dimensionSizes[1]], ['Mean'] + self.signalHeader.dimensionSizes[1] * [''], self.signalHeader.samplingRate) self.output[0].append(outputHeader) elif (type(self.input[0][chunkIndex]) == OVSignalBuffer): #Check if Condition != 0 , Meaning user has been clicked start scenario #if(self.phase != 0): chunk = self.input[0].pop() numpyBuffer = np.array(chunk).reshape( tuple(self.signalHeader.dimensionSizes)) #with open("C:/Users/h4wk/Desktop/Temp/foo.csv",'ab') as f: #path = os.getcwd() + datetime.datetime.now().strftime("%B %d, %Y") + ".csv" # if(self.phase != 0): path = self.setting[ 'OutputPath'] + '/BCI_GTEC_' + datetime.datetime.now( ).strftime("%Y%m%d_" + self.setting['subject_no']) + ".csv" with open(path, 'ab') as f: #t = time.localtime() #print("Current path:" + path) x = datetime.datetime.now() #a = np.asarray([[time.mktime(x.timetuple()), #Header Pattern: Timestamp, phase, scenario, subjectno, gender, age, type, count a = np.asarray(int(round(time.time() * 1000)), dtype=object) # print(a) # np.savetxt(f, a, delimiter=",", fmt='%5s') for channel in numpyBuffer: channel = np.insert(channel, 0, a, axis=0) # print(channel.shape) np.savetxt(f, [channel], delimiter=",") #==================Sending to ROS Server==========================# #print(self.counter) # if(self.counter >= 20): # self.counter = 0 # #self.ros_client.on_ready(self.publisher.publish(Message({'data': numpyBuffer}))) # isConnected = self.ros_client.is_connected # #print("isConnected = ", isConnected) # if(isConnected): # print("sending data... ", numpyBuffer.tolist()) # #self.publisher.publish(Message({'data': numpyBuffer.tolist()})) # a = " ".join(str(i) for i in numpyBuffer.tolist()) # self.publisher.publish(Message({'data': a})) # #self.publisher.publish(Message({'data': 'hello test'})) # #self.publisher.unadvertise() # ==================End Sending to ROS Server==========================# numpyBuffer = numpyBuffer.mean(axis=0) chunk = OVSignalBuffer(chunk.startTime, chunk.endTime, numpyBuffer.tolist()) self.output[0].append(chunk) elif (type(self.input[0][chunkIndex]) == OVSignalEnd): self.output[0].append(self.input[0].pop()) def subscribing(self): self.publisher.subscribe(receive_message) def uninitialize(self): # nop return