def handle_message(self, mxmsg):
"""Handle DIODE_CONTROL_MESSAGE of Variable type.
expected commands are:
- .key == 'start' - start blinking with current freqs
- .key == 'stop' - stop blinking
- .key == 'update' - update blinker with values in value
eg. we might get .value == "1;2;3;4;5;6;7;8" meaning
that we are to blink those values.
Additionaly if .value[0] == -1 we turn in 'static ligth' mode."""
if mxmsg.type == types.DIODE_CONTROL_MESSAGE:
l_msg = variables_pb2.Variable()
l_msg.ParseFromString(mxmsg.message)
if l_msg.key == 'stop':
self.logger.info("Stop blinker!")
self.diodes_on()
elif l_msg.key == 'start':
self.logger.info("Start blinker!")
self.start_blinking()
elif l_msg.key == 'update':
self.logger.info('Update blinker!')
self.logger.info(l_msg.value)
self.update_freqs(l_msg.value)
self.start_blinking()
else:
self.logger.warning("Unrecognised blink control message! " +
str(l_msg.key))
self.no_response()
def send_stop(conn):
msg = variables_pb2.Variable()
msg.key = 'stop'
msg.value = ''
conn.send_message(message=msg.SerializeToString(),
type=types.DIODE_CONTROL_MESSAGE,
flush=True)
def send_hide(conn):
msg = variables_pb2.Variable()
msg.key = 'hide'
msg.value = ''
conn.send_message(message=msg.SerializeToString(),
type=types.UGM_CONTROL_MESSAGE,
flush=True)
def send_freqs(conn, freqs):
msg = variables_pb2.Variable()
msg.key = 'update'
msg.value = ';'.join(freqs)
conn.send_message(message=msg.SerializeToString(),
type=types.DIODE_CONTROL_MESSAGE,
flush=True)
def process_message(self, message):
# should represent UgmUpdate type...
l_msg = variables_pb2.UgmUpdate()
try:
l_msg.ParseFromString(message)
if len(l_msg.value) == 0:
raise Exception(
"UgmUpdate message len is 0. Assumed parse error!!!")
l_time = time.time()
self._ugm_engine.queue_message(l_msg)
self.context['logger'].debug("Got ugm update message: ")
self.context['logger'].debug(l_msg.value)
if self._use_tagger:
self._tagger.send_tag(l_time, l_time, "ugm_update",
{"ugm_config": str(l_msg.value)})
except:
self.context['logger'].info(
"Couldnt parse message, too big ugm update message or not UGM_UPDATE_MESSAGE... Try UGM_CONTROL_MESSAGE"
)
l_msg = variables_pb2.Variable()
try:
l_msg.ParseFromString(message)
self.context['logger'].info(
"Properly parsed UGM_CONTROL_MESSAGE...")
self._ugm_engine.control(l_msg)
except:
self.context['logger'].info(
"PARSER ERROR, too big ugm control message or not UGM_CONTROL_MESSAGE... Do nothing!"
)
def run(self):
try:
while True:
conn, addr = self.socket.accept()
l_data = conn.recv(1024)
msg = variables_pb2.Variable()
msg.ParseFromString(l_data)
os.system("touch " + os.path.expanduser(
"~/obci/interfaces/etr/natural/calibFlag"))
time.sleep(0.4)
print "\n" * 10 + "*" * 10 + "\n" * 10
print "msg: ", msg.key, ' / ', msg.value
#~ l_msg = None #tu bedzie parsowanie wiadomosci o starcie i koncu kalibracji
#~ if l_msg is not None:
#~ pass
self.invH = np.load(
os.path.expanduser(
"~/obci/interfaces/etr/natural/calibMat.npy"))
print self.invH
#~ self.invH = self.calibrationStart()
#~ self.invH = self.fakeMatrix()
self._send_results()
finally:
self.socket.close()
def send_keyboard_event(self, key):
self.context['logger'].debug("Send keyboard event " + str(key))
msg = variables_pb2.Variable()
msg.key = "keybord_event"
msg.value = str(key)
self.connection.send_message(message=msg.SerializeToString(),
type=types.UGM_ENGINE_MESSAGE,
flush=True)
def send_mouse_event(self, button_nr):
self.context['logger'].debug("Send mouse event " + str(button_nr))
msg = variables_pb2.Variable()
msg.key = "mouse_event"
msg.value = str(button_nr)
self.connection.send_message(message=msg.SerializeToString(),
type=types.UGM_ENGINE_MESSAGE,
flush=True)
def send_blinking_stopped(self):
self.context['logger'].debug("Send blinking stopped")
msg = variables_pb2.Variable()
msg.key = "blinking_stopped"
msg.value = str(time.time())
self.connection.send_message(message=msg.SerializeToString(),
type=types.UGM_ENGINE_MESSAGE,
flush=True)
def _handle_ugm_engine(self, msg):
m = variables_pb2.Variable()
m.ParseFromString(msg)
if m.key == "blinking_stopped":
LOGGER.info("Got blinking stopped message!")
self._trials_counter -= 1
if self._trials_counter <= 0:
LOGGER.info("All trials passed")
self.end()
else:
LOGGER.info("Blinking stopped...")
self.blinking_stopped()
else:
LOGGER.info("Got unrecognised ugm engine message: " + str(m.key))
def run(self):
try:
while True:
l_data, addr = self.socket.recvfrom(1024)
msg = variables_pb2.Variable()
msg.ParseFromString(l_data)
msg.key, msg.value # jedno z nich to timestamp i start_calibration
l_msg = None #tu bedzie parsowanie wiadomosci o starcie i koncu kalibracji
if l_msg is not None:
pass
#tu pewnie będzie czytanie obrazu z kamery i po otrzymaniu info o stopie kalibracji
#pewnie bedzie odpalenie send_results
finally:
self.socket.close()
def handle_message(self, mxmsg):
'''Receives message HAPTIC_CONTROL_MESSAGE and sends it
to stimulation board.
Message contains info of type::
message Variable {
required string key = 1;
required string value = 2;
}
:param key: 'S', or 'T' - 'S' - to activate haptic channel(s); 'T' - to terminate FTDI
control process and release device
:param value: 'T' - doesn't matter; S - ex. '1,2:1.0,0.4' - activate channel 1 for
1 second and channel 2 for 0.4 seconds. Channels can be in any
order'''
if mxmsg.type == types.HAPTIC_CONTROL_MESSAGE:
l_msg = variables_pb2.Variable()
l_msg.ParseFromString(mxmsg.message)
if l_msg.key == 'S':
logs = 'Activating multiple haptic channels msg: {}'.format(l_msg)
self.logger.info(logs)
chnl_ls, time_ls = l_msg.value.split(':') #strings of lists
chnl_s = [i for i in chnl_ls.split(',')]
if not set(chnl_s).issubset(self.active_channels):
self.stim.close()
exc_msg = '''
Stimulated channel NOT in active channels
Available: {}
Tried to stimulate: {}
'''.format(self.active_channels, chnl_s)
raise Exception (exc_msg)
chnl = [int(i) for i in chnl_s]
time = [float(i) for i in time_ls.split(',')]
self.stim.bulk_stimulate(chnl, time)
elif l_msg.key == 'T':
self.logger.info('Shutting down')
self.stim.close()
sys.exit(0)
self.no_response()
def handle_message(self, mxmsg):
if mxmsg.type == types.UGM_ENGINE_MESSAGE:
l_msg = variables_pb2.Variable()
l_msg.ParseFromString(mxmsg.message)
if (l_msg.key == 'mouse_event' and l_msg.value == self.mouse_button) or \
(l_msg.key == 'keybord_event' and l_msg.value == self.key_code):
self.logger.info("Got ugm engine message: "+l_msg.key+" - "+l_msg.value+". Send switch message!")
self.conn.send_message(message = "",
type = types.SWITCH_MESSAGE, flush=True)
else:
self.logger.warning(''.join(["Got ugm engine message: ",
l_msg.key, " - ", l_msg.value,
" but not sending switch! ",
"Expected key-mouse is: ", self.key_code, " - ",self.mouse_button
])
)
else:
self.logger.warning("Got unrecognised message: "+str(mxmsg.type))
self.no_response()
def generate_test_messages(self):
'''
Generates test messages for Haptic stimulator
tries to cover all possible combinations of stimulation
'''
time.sleep(3)
msg = variables_pb2.Variable()
msg.key = 'S'
msg.value = '1:1.0'
self.conn.send_message(message=msg.SerializeToString(),
type=types.HAPTIC_CONTROL_MESSAGE,
flush=True)
self.logger.info('RUNNING! S1')
time.sleep(4)
msg = variables_pb2.Variable()
msg.key = 'S'
msg.value = '2:0.5'
self.conn.send_message(message=msg.SerializeToString(),
type=types.HAPTIC_CONTROL_MESSAGE,
flush=True)
self.logger.info('RUNNING! S2')
time.sleep(4)
msg = variables_pb2.Variable()
msg.key = 'S'
msg.value = '1,2:1.5,2.5'
self.conn.send_message(message=msg.SerializeToString(),
type=types.HAPTIC_CONTROL_MESSAGE,
flush=True)
self.logger.info('RUNNING! S1+2')
time.sleep(4)
msg = variables_pb2.Variable()
msg.key = 'S'
msg.value = '1:3'
self.conn.send_message(message=msg.SerializeToString(),
type=types.HAPTIC_CONTROL_MESSAGE,
flush=True)
self.logger.info('RUNNING! S1+2 in combination')
time.sleep(1)
msg = variables_pb2.Variable()
msg.key = 'S'
msg.value = '2:1'
self.conn.send_message(message=msg.SerializeToString(),
type=types.HAPTIC_CONTROL_MESSAGE,
flush=True)
time.sleep(5)
msg = variables_pb2.Variable()
msg.key = 'S'
msg.value = '1:10'
self.conn.send_message(message=msg.SerializeToString(),
type=types.HAPTIC_CONTROL_MESSAGE,
flush=True)
self.logger.info('RUNNING! S1')
msg = variables_pb2.Variable()
msg.key = 'S'
msg.value = '5:1'
self.conn.send_message(message=msg.SerializeToString(),
type=types.HAPTIC_CONTROL_MESSAGE,
flush=True)
self.logger.info('Sending wrong channel')
time.sleep(5)
sys.exit(0)