def configure(self, rf):
"""Configure the module according to the configuration file
Args:
rf (string): name of the configuration file of the module.
This file must be include in the folder pointing to the yarp
contexts. By default: rf = 'default.ini'
"""
self.handlerPort.open("/ErgonomicAssessmentModule")
self.attach(self.handlerPort)
self.in_port_posture = yarp.BufferedPortBottle()
self.in_port_posture.open('/ergo_pred/posture:i')
path_config_posture = rf.find('posture_config').toString()
self._posture = HumanPosture(path_config_posture)
path_config_ergo = rf.find('ergo_config').toString()
self._ergo_assessment = ErgoAssessment(path_config_ergo)
self.list_out_port_ergo = dict()
for ergo_score in self._ergo_assessment.get_list_score():
self.list_out_port_ergo[ergo_score] = yarp.BufferedPortBottle()
self.list_out_port_ergo[ergo_score].open("/ergo_pred/" +
ergo_score.lower() + ':o')
return True
def __init__(self):
super(self.__class__, self).__init__()
self.setupUi(self)
# we update the probability at 100 Hz
self.__timer = QTimer()
self.__timer.timeout.connect(self.update_probabilities)
self.__timer.start(10) # every 10 ms
# Port for initialization of center of mass position
self.InitButton.clicked.connect(self.initialize_com)
self.port_init = yarp.BufferedPortBottle()
self.port_init.open('/reco_gui/init_com:o')
self.activity = yarp.Network.connect('/reco_gui/init_com:o',
'/processing/init_com:i')
# Prepare yarp ports
self.activity_input = '/activity_recognition/probabilities:o'
self.port_activity = yarp.BufferedPortBottle()
self.port_activity.open('/gui/probabilities')
yarp.Network.connect(self.activity_input, self.port_activity.getName())
self.contact_input = '/DetectionContact'
self.port_contact = yarp.BufferedPortBottle()
self.port_contact.open('/gui/contact')
self.cback = CallbackData(1)
self.port_contact.useCallback(self.cback)
self.contact = yarp.Network.connect(self.contact_input,
self.port_contact.getName())
self.flag_init = 0
def configure(self, rf):
"""Configure the module according to the configuration file
Args:
rf (string): name of the configuration file of the module.
This file must be include in the folder pointing to the yarp
contexts. By default: rf = 'default.ini'
"""
self.handlerPort.open("/AE_Module")
self.attach(self.handlerPort)
self.in_port_posture = yarp.BufferedPortBottle()
self.in_port_posture.open('/AE/posture:i')
path_AE = rf.find('path_AE').toString()
with open(path_AE, 'rb') as input:
self._autoencoder = pickle.load(input)
self.out_port_reconstruct = yarp.BufferedPortBottle()
self.out_port_reconstruct.open("/AE/reconstruct:o")
self.out_port_latent = yarp.BufferedPortBottle()
self.out_port_latent.open("/AE/latent:o")
return True
def port_setup(robot_name):
""" Open the input and output ports."""
global local_in_port
global local_out_port
global local_in_port_name
global local_out_port_name
global ors_in_port_name
global ors_out_port_name
# Define the names for all the ports
port_prefix = "/ors/robots/" + robot_name + "/"
local_port_prefix = "/pa10_client/" + robot_name + "/"
ors_in_port_name = port_prefix + "OBPA-10/in"
ors_out_port_name = port_prefix + "out"
local_in_port_name = local_port_prefix + "in/"
local_out_port_name = local_port_prefix + "out/"
# Start the yarp network connection
yarp.Network.init()
# Open the client ports
local_in_port = yarp.BufferedPortBottle()
local_in_port.open(local_in_port_name)
local_out_port = yarp.BufferedPortBottle()
local_out_port.open(local_out_port_name)
# Connect the client ports to the simulator ports
yarp.Network.connect(local_out_port_name, ors_in_port_name)
yarp.Network.connect(ors_out_port_name, local_in_port_name)
def __init__(self):
yarp.RFModule.__init__(self)
self.xtionResolution = (640, 480)
# Define port variable to recive an image from Teo's camera
self.xtionImagePort = yarp.BufferedPortImageRgb()
# Create numpy array to receive the image
self.xtionImageArray = np.zeros(
(self.xtionResolution[1], self.xtionResolution[0], 3),
dtype=np.uint8)
self.xtionObjectDetectionsPort = yarp.BufferedPortBottle()
self.glassesImagePort = yarp.BufferedPortImageRgb()
self.glassesResolution = (1080, 1080)
self.glassesImageArray = np.zeros(
(self.glassesResolution[1], self.glassesResolution[0], 3),
dtype=np.uint8)
self.minConfidenceDetection = 0.9
self.triggerProb = 0.7
self.cropsResolution = (120, 120)
self.glassesDataPort = yarp.BufferedPortBottle()
self.tripletModel = None
self.embeddingModel = None
# Output Ports
self.fixationObjectPort = yarp.Port()
self.fixationObjectImagePort = yarp.BufferedPortImageRgb()
self.glassesCropImagePort = yarp.BufferedPortImageRgb()
self.detections = yarp.Bottle()
self.bottleData = yarp.Bottle()
self.count_not_detections = 0
self.max_count_not_detections = 10
self.rightObject = False
if robot == '/teo':
self.xtionImagePortName = "/xtion/rgbImage"
elif robot == '/teoSim':
self.xtionImagePortName = "/teoSim/camera/rgbImage"
self.xtionObjectDetectionPortName = "/rgbdObjectDetection/state"
self.glassesImagePortName = "/glassesServer/images"
self.glassesDataPortName = "/glassesServer/data"
self.fixationObjectPortName = "/object"
self.fixationObjectImagePortName = "/rgbImage"
self.glassesCropImagePortName = "/Glassescrop"
# Categories
self.categories = None
self.previous_category = 0
self.glassesCropImages = []
self.allDetectionsInWindowFrames = []
self.allDetectionsLabelsInWindowFrames = []
self.period = 0.01
self.timeToGrop = 0
self.numberOfFramesJustOneObject = 0
def configure(self, rf):
self.handlerPort.open("/ActivityRecognitionModule")
self.attach(self.handlerPort)
self.list_port = []
self.cback = []
path_model = rf.find('path_model').toString()
name_model = rf.find('name_model').toString()
self.statePort = yarp.BufferedPortBottle()
self.statePort.open('/activity_recognition/state:o')
self.probPort = yarp.BufferedPortBottle()
self.probPort.open('/activity_recognition/probabilities:o')
self.model = ModelHMM()
self.model.load_model(path_model + '/' + name_model)
self.list_states = self.model.get_list_states()
self.buffer_model = [[]]
size_buffer = int(rf.find('size_buffer').toString())
signals = rf.findGroup("Signals").tail().toString().replace(')', '').replace('(', '').split(' ')
nb_port = int(len(signals))
nb_active_port = 0
for signal in signals:
info_signal = rf.findGroup(signal)
is_enabled = int(info_signal.find('enable').toString())
if(is_enabled):
list_items = info_signal.findGroup('list').tail().toString().split(' ')
input_port_name = info_signal.find('output_port').toString()
if(input_port_name == ''):
input_port_name = info_signal.find('input_port').toString()
if((list_items[0] == 'all') or (list_items[0] == '')):
self.list_port.append(yarp.BufferedPortBottle())
self.list_port[nb_active_port].open("/activity_recognition" + input_port_name + ':i')
self.cback.append(CallbackData(size_buffer))
self.list_port[nb_active_port].useCallback(self.cback[nb_active_port])
yarp.Network.connect("/processing" + input_port_name + ':o', self.list_port[nb_active_port].getName())
nb_active_port += 1
self.buffer_model.append([])
else:
for item in list_items:
self.list_port.append(yarp.BufferedPortBottle())
self.list_port[nb_active_port].open("/activity_recognition" + input_port_name + '/' + item + ':i')
self.cback.append(CallbackData(size_buffer))
self.list_port[nb_active_port].useCallback(self.cback[nb_active_port])
self.buffer_model.append([])
yarp.Network.connect("/processing" + input_port_name + '/' + item + ':o', self.list_port[nb_active_port].getName())
nb_active_port += 1
self.flag_model = np.zeros(nb_active_port)
self.obs = []
return True
def test_open_and_connect(self):
p = yarp.BufferedPortBottle()
p2 = yarp.BufferedPortBottle()
self.assertTrue(p.open("/python/out"))
self.assertTrue(p2.open("/python/in"))
self.assertTrue(yarp.Network.connect(p.getName(), p2.getName()))
p.close()
p2.close()
def port_setup(): global local_in_port global local_out_port yarp.Network.init() local_in_port = yarp.BufferedPortBottle() local_in_port.open(local_in_port_name) local_out_port = yarp.BufferedPortBottle() local_out_port.open(local_out_port_name) yarp.Network.connect (local_out_port_name, ors_in_port_name) yarp.Network.connect (ors_out_port_name, local_in_port_name)
def __init__(self, list_port):
self.input_port = []
self.port = []
plt.ion()
self.fig = plt.figure()
self.ax = self.fig.add_subplot(111, projection='3d')
data = np.zeros((2, 66))
color = ['b', 'r']
self.lines = []
self.skeleton = []
self.skeleton = Skeleton('dhm66_ISB_Xsens.urdf')
for i, name_port in enumerate(list_port):
self.input_port.append(name_port)
self.port.append(yarp.BufferedPortBottle())
self.port[i].open('/plot_skeleton' + name_port)
yarp.Network.connect(name_port, self.port[i].getName())
self.lines = self.skeleton.visualise_from_joints(data,
color_list=color,
lines=[])
def receiver(AV_port_name, HW_port_name, queue):
"""
This function implements the communication with the microphone through YARP
framework, appending all the message received to a queue.
:param AV_port_name: name of the receiver port
:param HW_port_name: name of the sender port
:param queue: process shared queue
"""
# Create and connect the port
AV_port = yarp.BufferedPortBottle()
AV_port.open(AV_port_name)
yarp.Network.connect(HW_port_name, AV_port_name)
while True:
# Read the bottle message and convert to AudioData type
btl = AV_port.read()
print(btl)
timestamp = btl.get(0).asInt64()
print(timestamp)
raw_audio = btl.get(1).asBlob()
print(raw_audio)
queue.put([timestamp, raw_audio])
# Cleanup
AV_port.close()
def test_open_and_connect_comm(self):
p = yarp.BufferedPortBottle()
p2 = yarp.BufferedPortBottle()
bt_out = p.prepare()
bt_out.addInt32(10)
self.assertTrue(p.open("/python/out"))
self.assertTrue(p2.open("/python/in"))
self.assertTrue(yarp.Network.connect(p.getName(), p2.getName()))
yarp.delay(0.5)
p.write()
yarp.delay(0.5)
bt_in = p2.read()
self.assertEqual(1, bt_in.size())
self.assertEqual(10, bt_in.get(0).asInt32())
p.close()
p2.close()
def __init__(self, input_port_name, output_port_name, display_port_name):
yarp.RFModule.__init__(self)
# Prepare ports
self._input_port = yarp.Port()
self._input_port_name = input_port_name
self._input_port.open(self._input_port_name)
self._output_port = yarp.BufferedPortBottle()
self._output_port_name = output_port_name
self._output_port.open(self._output_port_name)
self._display_port = yarp.Port()
self._display_port_name = display_port_name
self._display_port.open(self._display_port_name)
# Prepare image buffers
# Input
self._input_buf_image = yarp.ImageRgb()
self._input_buf_image.resize(320, 240)
self._input_buf_array = np.zeros((240, 320, 3), dtype=np.uint8)
self._input_buf_image.setExternal(self._input_buf_array,
self._input_buf_array.shape[1], self._input_buf_array.shape[0])
# Output
self._display_buf_image = yarp.ImageRgb()
self._display_buf_image.resize(320, 240)
self._display_buf_array = np.zeros((240, 320, 3), dtype=np.uint8)
self._display_buf_image.setExternal(self._display_buf_array,
self._display_buf_array.shape[1], self._display_buf_array.shape[0])
self._logger = yarp.Log()
def __init__(self, configuration):
threading.Thread.__init__(self)
self.name = "skinThread"
self.config = configuration
self.skinPart = "SKIN_PART_UNKNOWN, left_hand, SKIN_LEFT_FOREARM, SKIN_LEFT_UPPER_ARM, right_hand, head, SKIN_RIGHT_UPPER_ARM, torso, LEFT_LEG_UPPER, LEFT_LEG_LOWER, LEFT_FOOT, RIGHT_LEG_UPPER, RIGHT_LEG_LOWER, RIGHT_FOOT, SKIN_PART_ALL, SKIN_PART_SIZE".split(
", ")
if self.config.status:
try:
if self.config.isRecording:
self.lastTouchside = False
self.exportTouch = open(
self.config.exportName + "_touch.py", 'w')
self.exportTouch.write("times = []\n")
self.exportTouch.write("side = []\n")
yarp.Network.init() # Init yarp
self.manager = yarp.BufferedPortBottle() # init Bottle
self.manager.open("/skinManager") # Open new port
yarp.Network.connect(
"/skinManager/skin_events:o",
"/skinManager") # connect Nao port with virtual port
except:
sharedIsrunningLock.acquire()
sharedIsrunning = False
sharedIsrunningLock.release()
def __init__(self, portName):
super(yarpOutGrabber, self).__init__()
#yarp.Network.init()
self.port_name = portName
self.port = yarp.BufferedPortBottle()
self.bottle = yarp.Bottle()
def __init__(self,
namePortToRead='/matlab/write',
namePortToWrite='/matlab/HP'):
""""Connexion entre :
- /VTSFE/state:o et namePortToWrite
- namePortToRead et /VTSFE/latentSpace:i"""
yarp.Network.init()
self.pw = yarp.BufferedPortBottle()
self.pw.open('/ae/state:o')
self.portMatlabOutput = namePortToRead
self.portMatlabInput = namePortToWrite
self.pr = yarp.BufferedPortBottle()
self.pr.open('/ae/latentSpace:i')
yarp.Network.connect(self.portMatlabOutput, self.pr.getName())
yarp.Network.connect(self.pw.getName(), self.portMatlabInput)
def __init__(self):
yarp.RFModule.__init__(self)
self.image = np.zeros((240, 304))
self.image_buf = np.zeros((240, 304))
self.input_port = yarp.BufferedPortBottle()
self.rpc_port = yarp.RpcServer()
cv2.namedWindow("events", cv2.WINDOW_NORMAL)
self.mutex = threading.Lock()
class motor_x(position)
#starting a yarp network
y.Network_init()
#creating an ouput port for stm32_x position
out_1 = y.BufferedPortBottle()
out_1_name = "/stm32_"+ self.position "/position/out1"
out_1.open(out_1_name)
#creating a input port
in_1 = y.BufferedPortBottle()
in_1_name = "/stm32_"+ self.position "/position/in1"
in_1.open(in_1_name)
#creating an input port from ps3 controller
in_speed = y.BufferedPortBottle()
in_speed_name = "/stm32_"+ self.position "/position/in1"
in_speed.open(in_speed_name)
def __init__(self, module_name, robot_name, task_name):
port_prefix = '/' + robot_name + '/' + module_name + '/' + task_name + '/'
self.set_ref = yarp.BufferedPortBottle()
self.set_ref.open(port_prefix + 'set_ref:o')
self.set_ref.addOutput(port_prefix + 'set_ref:i')
#yarp.Network.connect(port_prefix+'set_ref:o',
# port_prefix+'set_ref:i')
self.rpc = yarp.RpcClient()
self.rpc.open(port_prefix + 'rpc_client')
self.rpc.addOutput(port_prefix + 'rpc')
def __init__(self, parent=None):
list_port = ['/processing/xsens/JointAngles:o', '/AE/reconstruct:o']
self.input_port = []
self.port = []
self.fig = plt.figure()
self.ax = self.fig.add_subplot(111, projection='3d')
data = np.zeros((1, 66))
color = ['b', 'r']
self.lines = []
self.skeleton = []
self.skeleton = Skeleton('dhm66_ISB_Xsens.urdf')
for i, name_port in enumerate(list_port):
self.input_port.append(name_port)
self.port.append(yarp.BufferedPortBottle())
self.port[i].open('/plot_skeleton' + name_port)
yarp.Network.connect(name_port, self.port[i].getName())
QtWidgets.QWidget.__init__(self, parent) # Inherit from QWidget
self.fig = Figure()
self.pltCanv = Canvas(self.fig)
self.pltCanv.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.pltCanv.setFocusPolicy(QtCore.Qt.ClickFocus)
self.pltCanv.setFocus()
self.pltCanv.updateGeometry()
self.ax = self.fig.add_subplot(111, projection='3d')
self.ax.mouse_init()
#=============================================
# Main plot widget layout
#=============================================
self.layVMainMpl = QVBoxLayout()
self.layVMainMpl.addWidget(self.pltCanv)
self.setLayout(self.layVMainMpl)
self.lines = []
self.skeleton = []
self.skeleton = Skeleton('dhm66_ISB_Xsens.urdf')
self.timer = self.pltCanv.new_timer(100,
[(self.update_canvas, (), {})])
self.timer.start()
def configure(self, rf):
yarp.Network.init()
self.respondPort = yarp.Port()
self.inputPort = yarp.BufferedPortBottle()
self.outputPort = yarp.BufferedPortBottle()
self.respondPort.open('/pythonRFMod')
self.inputPort.open('/pythonRead')
self.outputPort.open('/pythonWrite')
self.attach(self.respondPort)
yarp.Network.connect('/write', '/pythonRead')
yarp.Network.connect('/pythonWrite', '/read')
self.inputBottle = yarp.Bottle()
self.outputBottle = yarp.Bottle()
self.uniCom = 'None'
print 'configured'
return True
def __init__(self, reader_port):
print('\n\nInitializing predictor...')
yarp.RFModule.__init__(self)
# self._pattern = re.compile('(\d*) (\d*.\d*) (\w*) \((.*)\)')
# Open YARP ports
print('\nOpening yarp ports...')
self._reader_port = yarp.BufferedPortBottle()
self._reader_port.open(reader_port)
yarp.Network.connect('/zynqGrabber/AE:o', reader_port,
'udp') # AUTOMATIC CONNECTION - REMOVE IN FUTURE
print('\nPorts opened successfully!')
def run(self):
i = 0
input_port = yarp.BufferedPortBottle()
input_port.open(self.portname)
input_port.useCallback(self.rec)
st = yarp.Stamp()
while not self.killswitch.is_set():
input_port.getEnvelope(st)
ts = st.getTime()
b = self.decode_q.get()
binp = event_driven.bottleToVBottle(b)
data = event_driven.getData(binp)
self.out_q.put((ts, data))
i += 1
def __init__(self, name, out_port, carrier=""):
"""
Initializing the NativeObjectPublisher
:param name: Name of the publisher
:param out_port: The published port name preceded by "/"
:param carrier: For a list of carrier names, visit https://www.yarp.it/carrier_config.html. Default is "tcp"
"""
super().__init__()
self.__name__ = name
self._port = yarp.BufferedPortBottle()
self._port.open(out_port)
self.__netconnect__ = yarp.Network.connect(out_port, out_port + ":out",
carrier)
def configure(self, rf):
# Setting up rpc port
self.portsList["rpc"] = yarp.Port()
self.portsList["rpc"].open("/deepSpeechToText:rpc:i")
self.attach(self.portsList["rpc"])
yarp.Network.connect("/sentence_tokenizer/audio:o",
self.portsList["rpc"].getName())
self.portsList["text_out"] = yarp.BufferedPortBottle()
self.portsList["text_out"].open("/deepSpeechToText/text:o")
self.portsList["tokenizer_rpc"] = yarp.BufferedPortBottle()
self.portsList["tokenizer_rpc"].open(
"/deepSpeechToText/tokenizer/rpc:o")
self.tokenizer_ctrl_bottle = self.portsList["tokenizer_rpc"].prepare()
yarp.Network.connect(self.portsList["tokenizer_rpc"].getName(),
"/sentence_tokenizer/rpc:i")
# Setting up deep speech model client
self.ds_model_file = join(self.ds_root_dir, "output_graph.pb")
self.ds_alphabet_file = join(self.ds_root_dir, "alphabet.txt")
self.ds_language_model = join(self.ds_root_dir, "lm.binary")
self.ds_trie = join(self.ds_root_dir, "trie")
self.ds_model = Model(self.ds_model_file, self.ds_N_FEATURES,
self.ds_N_CONTEXT, self.ds_alphabet_file,
self.ds_BEAM_WIDTH)
self.ds_model.enableDecoderWithLM(self.ds_alphabet_file,
self.ds_language_model, self.ds_trie,
self.ds_LM_WEIGHT,
self.ds_WORD_COUNT_WEIGHT,
self.ds_VALID_WORD_COUNT_WEIGHT)
print "Model loaded and ready to start"
return True
def main():
# ros node initialisation
rospy.init_node('imu_recorder', disable_signals=True)
# reading file and path name from the ros parameter server
file_name = rospy.get_param('~file_name', 'recording')
file_path = rospy.get_param('~file_path', '')
# setting the file and path name for the recorder
recorder.set_file_name(file_name, file_path)
# subscribing to the inertial data topic
rospy.Subscriber("/imu_data", Imu, callback)
# setting yarp port for key pressure
inputPortname = '/smartwatch/keyboard:i'
inputPort = yarp.BufferedPortBottle()
inputPort.open(inputPortname)
# setting keyboard letters behavior
reset = rospy.get_param('~reset_letter', 'nan')
stop = rospy.get_param('~stop_letter', 'nan')
if reset == "nan" or stop == "nan":
print "\n ERROR: set the reset and stop parameter in the launch file \n"
return
r = rospy.Rate(100)
while True:
try:
# reading yarp message
messageBottle = inputPort.read(False)
# handling keyboard pressure
if messageBottle != None:
receivedMessage = messageBottle.toString()
if receivedMessage == reset:
recorder.save_reset()
elif receivedMessage == stop:
recorder.set_recording(False)
recorder.save_file()
break
r.sleep()
except KeyboardInterrupt:
recorder.set_recording(False)
recorder.save_file()
inputPort.close()
break
def __init__(self, rf):
path_model = rf.find('path_model').toString()
self.input_port = '/activity_recognition/probabilities:o'
self.port = yarp.BufferedPortBottle()
self.port.open('/plot/probabilities')
self.plotWindow = pg.GraphicsWindow(title='Probabilities')
self.plotData = self.plotWindow.addPlot(title='Probabilities')
self.buffer = [[]]
self.list_curve = []
yarp.Network.connect(self.input_port, self.port.getName())
self.flag_init = 0
def __init__(self, rf):
self.input_port = '/processing/eglove/data/Forces:o'
self.port = yarp.BufferedPortBottle()
self.port.open('/DetectionContact')
path_model = rf.find('path_model').toString()
name_model = rf.find('name_model').toString()
self.model = ModelHMM()
self.model.load_model(path_model + '/' + name_model)
self.list_states = self.model.get_list_states()
self.buffer_model = []
self.obs = []
print(self.list_states)
yarp.Network.connect(self.input_port, self.port.getName())
def __createPort(self, name, target=None, mode='unbuffered'):
""" This method returns a port object.
@param name - yarp name for the port
@param obj - object for which the port is created
@param buffered - if buffered is True a buffered port will be used otherwise not;
default is True.
@result port
"""
# create port
if mode == 'buffered':
port = yarp.BufferedPortBottle()
elif mode == 'rpcclient':
port = yarp.RpcClient()
elif mode == 'rpcserver':
port = yarp.RpcServer()
else:
port = yarp.Port()
# build port name
port_name = ['']
# prefix handling
if hasattr(self, 'prefix') and self.prefix:
port_name.append(self.prefix)
port_name.append(self.__class__.__name__)
port_name.append(name)
# open port
if not port.open('/'.join(port_name)):
raise RuntimeError, EMSG_YARP_NOT_FOUND
# add output if given
if target:
port.addOutput(target)
if hasattr(self, '_ports'):
self._ports.append(port)
return port
def __init__(self, name_port, size_window):
self.input_port = name_port
self.port = yarp.BufferedPortBottle()
self.port.open('/plot' + name_port)
self.plotWindow = pg.GraphicsWindow(title=name_port)
self.plotData = self.plotWindow.addPlot(title=name_port)
self.buffer = [[]]
self.list_curve = []
self.size_window = size_window
print(name_port)
yarp.Network.connect(name_port, self.port.getName())
self.flag_init = 0
def __init__(self, rf):
path_model = rf.find('path_model').toString()
self.input_port = '/activity_recognition/probabilities:o'
self.port = yarp.BufferedPortBottle()
self.port.open('/plot/probabilities')
self.plotWindow = pg.GraphicsWindow(title='Probabilities')
self.plotData = self.plotWindow.addPlot(title='Probabilities')
self.buffer = [[]]
self.list_curve = []
if yarp.Network.connect(self.input_port, self.port.getName())== False:
print('*** The activity recognition port cannot be found, closing ')
self.close()
return False
self.flag_init = 0
