def _gaze_to_packets(self, source): sample_count = 0 packet = variables_pb2.SampleVector() samples_per_packet = int(self.get_param("samples_per_packet")) for gaze_data in source: sample = packet.samples.add() sample.timestamp = int(time.time()) sample.channels.extend(self.extract_channels(gaze_data)) sample_count += 1 if sample_count == samples_per_packet: yield packet packet = variables_pb2.SampleVector() sample_count = 0
def _first_sample_data_received(self, p_data): """Validate p_data (is it a correct float? If not exit the program.), send it to data_proxy. first_sample_data_received is set to self.data_received in self.__init__, so in fact first_sample_data_received is fired externally by calling self.data_received""" # Set some additional first_sample-like data msg = p_data l_vec = variables_pb2.SampleVector() l_vec.ParseFromString(msg) self.logger.info("REAL SAMPLES PER PACKET: "+str(len(l_vec.samples))) for i_sample in l_vec.samples: self._first_sample_timestamp = i_sample.timestamp self.logger.info("First sample sample ts:" + repr(self._first_sample_timestamp)) self.logger.info("First sample system ts:" + repr(time.time())) self.logger.info("REAL NUM OF CHANNELS:"+str(len(i_sample.channels))) break #self._first_sample_timestamp = time.time() #break self._data_proxy.set_data_len(len(p_data), self._samples_per_packet) self._data_proxy.set_first_sample_timestamp(self._first_sample_timestamp) self.logger.info("Data len: "+str(len(p_data))) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # !!! below operation changes self._data_received method # from _first_sample_timestamp to _all_but_first_data_received self._data_received = self._all_but_first_data_received # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! self._data_received(p_data)
def handle_message(self, mxmsg): #always buffer signal if mxmsg.type == types.AMPLIFIER_SIGNAL_MESSAGE: l_msg = variables_pb2.SampleVector() l_msg.ParseFromString(mxmsg.message) #Supply buffer with sample data, the buffer will fire its #ret_func (that we defined as self.analysis.analyse) every 'every' samples self.buffer.handle_sample_vect(l_msg) if DEBUG: self.debug.next_sample() #process blinks only when hold_time passed if self._last_dec_time > 0: t = time.time() - self._last_dec_time if t > self.hold_after_dec: self._last_dec_time = 0 ugm_helper.send_start_blinking(self.conn) else: self.no_response() return if mxmsg.type == types.BLINK_MESSAGE: l_msg = variables_pb2.Blink() l_msg.ParseFromString(mxmsg.message) self.buffer.handle_blink(l_msg) self.no_response()
def _create_msg(self, samples): assert (self.samples_per_packet == len(samples)) v = variables_pb2.SampleVector() for sample, ts in samples: s = v.samples.add() s.channels.extend(sample) s.timestamp = ts return v
def _samples_callback(self, params): self.collected_samples.append((params[0], params[1])) if len(self.collected_samples) == self.samples_per_packet: v = variables_pb2.SampleVector() for ts, sample in self.collected_samples: s = v.samples.add() s.channels.extend(sample) s.timestamp = ts self.collected_samples = [] self._send(self._create_mx_msg(v))
def handle_message(self, mxmsg): if mxmsg.type == self.in_mx_signal_type: v = variables_pb2.SampleVector() v.ParseFromString(mxmsg.message) for s in v.samples: msg = self.get_msg(s) self.conn.send_message(message=msg.SerializeToString(), type=self.out_mx_signal_type, flush=True) print msg self.no_response()
def handle_message(self, mxmsg): if mxmsg.type == self.in_mx_signal_type: v = variables_pb2.SampleVector() v.ParseFromString(mxmsg.message) for s in v.samples: msg = variables_pb2.Sample2D() msg.x = s.channels[self.x_ind] msg.y = s.channels[self.y_ind] msg.timestamp = s.timestamp self.conn.send_message( message=msg.SerializeToString(), type=self.out_mx_signal_type, flush=True) self.no_response()
def handle_message(self, mxmsg): if mxmsg.type == types.AMPLIFIER_SIGNAL_MESSAGE: if DEBUG: self.debug.next_sample() msg = mxmsg.message l_vec = variables_pb2.SampleVector() l_vec.ParseFromString(msg) self.logger.debug("Got pack of samples in moment: "+str(time.time())) for i_sample in l_vec.samples: diff = time.time()-i_sample.timestamp comm = ''.join([ "Sample ts: ", str(i_sample.timestamp), " / Real ts:"+str(time.time()), " / "+"DIFF: "+str(diff)]) self.logger.debug(comm) if diff > 0.1: self.logger.error(comm+"\n\n") if self.amp_saw_ind >= 0: v = i_sample.channels[self.amp_saw_ind] if self._amp_saw_last + self.amp_saw_step - v > 0: self.logger.error("Last: "+str(self._amp_saw_last)+" Amp saw: "+str(v)) self.logger.error(''.join(["LOOOOOOOOST AMPLIFIER SAMPLES, sth like: ", str(self._amp_saw_last + self.amp_saw_step - v), " samples!!!" ])+"\n\n") if v == self.amp_saw_max: self._amp_saw_last = -self.amp_saw_step + 1 else: self._amp_saw_last = v self.logger.debug("Amp saw: "+str(v)) if self.driver_saw_ind >= 0: v = i_sample.channels[self.driver_saw_ind] if self._driver_saw_last + self.driver_saw_step - v > 0: self.logger.error("Last: "+str(self._driver_saw_last)+" Driver saw: "+str(v)) self.logger.error(''.join(["LOOOOOOOOST DRIVER SAMPLES, sth like: ", str(self._driver_saw_last + self.driver_saw_step - v), " samples!!!" ])+"\n\n") if v == self.driver_saw_max: self._driver_saw_last = -self.driver_saw_step + 1 else: self._driver_saw_last = v self.logger.debug("Driver saw: "+str(v)) self.logger.debug("First channel value: "+str(i_sample.channels[0])) else: self.logger.error("Got unrecognised message!!!") self.no_response()
def handle_message(self, mxmsg): if mxmsg.type == self.in_mx_signal_type: v = variables_pb2.SampleVector() v.ParseFromString(mxmsg.message) for s in v.samples: msg = variables_pb2.Sample2D() x, y = wii_utils.get_x_y(s.channels[0], s.channels[1], s.channels[2], s.channels[3]) msg.x = 0.5 - x * 0.5 msg.y = 0.5 - y * 0.5 msg.timestamp = s.timestamp self.conn.send_message(message=msg.SerializeToString(), type=self.out_mx_signal_type, flush=True) self.no_response()
def handle_message(self, mxmsg): """The only required function in the class that will be fired every time message is received""" if mxmsg.type == types.AMPLIFIER_SIGNAL_MESSAGE: # Got proper message, let`s unpack it ... # Messages are transmitted in bunches so lets define SampleVector # in order to unpack bunch of Sample messages ... l_vect = variables_pb2.SampleVector() l_vect.ParseFromString(mxmsg.message) # Now we have message unpacked, lets iterate over every sample ... for s in l_vect.samples: # Every sample has two fields: # timestamp - system clock time of a moment of Sample`s creation # channels - a list of values - one for every channel self.logger.debug("Got sample with timestamp: " + str(s.timestamp)) # One can copy samples to numpy array ... a = numpy.array(s.channels) # Or just iterate over values ... for ch in s.channels: self.logger.debug(ch) # Having a new bunch of values one can fire some magic analysis and # generate decision .... # Below we have quite simple decision-maker - it generates a random # decision every ~100 samples-bunch if random.random() > 0.99: # Here we send DECISION message somewhere-to-the-system ... # It's up to scenario's configuration how the decision will be used ... # Eg. it might be used by LOGIC module to push some button in speller. msg = str(random.randint(0, 7)) self.logger.info("Send random message in analysis... " + msg) self.conn.send_message(message=msg, type=types.DECISION_MESSAGE, flush=True) else: self.logger.warning("Got unrecognised message type: " + str(mxmsg.type)) # Tell the system 'I`ll not respond to this message, I`m just receiving' self.no_response()
def handle_message(self, mxmsg): if mxmsg.type == types.WII_BOARD_SIGNAL_MESSAGE: if self._dummy: sway_direction, sway_level = self._calculate_dummy_sway() else: #calculate and send current sway direction and level v = variables_pb2.SampleVector() v.ParseFromString(mxmsg.message) X, Y = [], [] for s in v.samples: #todo - refactor in regard to utils/wii_2d_router sum_mass = sum(s.channels[0:4]) if sum_mass < 200: break x, y = wii_utils.get_x_y(s.channels[0], s.channels[1], s.channels[2], s.channels[3]) X.append(x) Y.append(y) if len(X): sway_direction, sway_level = self._calculate_real_sway( np.mean(X), np.mean(Y)) else: sway_direction, sway_level = 'baseline', 0 msg = variables_pb2.IntVariable() msg.key = sway_direction msg.value = sway_level self.conn.send_message(message=msg.SerializeToString(), type=types.WII_BOARD_ANALYSIS_RESULTS, flush=True) elif mxmsg.type == types.ACQUISITION_CONTROL_MESSAGE: # storing user's current maxes makes sens only in calibration scenario ... if self._session_name not in [ 'ventures_calibration', 'sway_with_feedback' ]: self.logger.info( "Got acquisition_control_message, but session name is " + self._session_name + " . Just exit quietly ...") sys.exit(0) else: #self._session_name == 'ventures_calibration' self.logger.info( "Got acquisition_control_message in calibration session. Start storing calibration results (maxes)... " ) self._store_calibration_results() sys.exit(0) else: self.logger.warning("Unrecognised message type!!!") self.no_response()
def get_sample_vector(per, ch_num, ts_step): """generate signal like: [ [1,2,3,4,5.... [10,20,30,40,50... [100,200,300, ... ... ] """ global COUNT sample_vector = variables_pb2.SampleVector() for x in range(per): COUNT += 1 samp = sample_vector.samples.add() for j in range(ch_num): samp.channels.append((10**(j)) * COUNT) #print(samp.channels[0]) samp.timestamp = time.time() time.sleep(ts_step) return sample_vector
def handle_message(self, mxmsg): if self._last_dec_time > 0: t = time.time() - self._last_dec_time if t > self.hold_after_dec: self._last_dec_time = 0 else: if mxmsg.type == types.AMPLIFIER_SIGNAL_MESSAGE and DEBUG: self.debug.next_sample() self.no_response() return if mxmsg.type == types.AMPLIFIER_SIGNAL_MESSAGE: l_msg = variables_pb2.SampleVector() l_msg.ParseFromString(mxmsg.message) #Supply buffer with sample data, the buffer will fire its #ret_func (that we defined as self.analysis.analyse) every 'every' samples self.buffer.handle_sample_vect(l_msg) if DEBUG: self.debug.next_sample() self.no_response()
def received_message(self, m): msg = json.loads(str(m)) timestamp = float(msg['timestamp']) sample = self.msg_vector.samples.add() sample.timestamp = timestamp try: sample.channels.extend(float(msg[i]) for i in self.peer.chs) except KeyError as e: unavailable_channels_set = set(self.peer.chs).difference( set(msg.keys())) unavailable_channels_msg = ', '.join(unavailable_channels_set) msg = ''' ERROR: UNAVAILABLE CHANNELS: {unavailable_channels} Channels from tracker server JSON: {available_channels} You've tried to access channels: {requested_channels} '''.format( unavailable_channels=unavailable_channels_msg, available_channels=', '.join(msg.keys()), requested_channels=', '.join(self.peer.chs), ) self.peer.logger.error(msg) raise KeyError(unavailable_channels_msg) if len(self.msg_vector.samples) == self.samples_per_packet: #send when big enough and create new empty vector self.peer.process_message(self.msg_vector) self.msg_vector = variables_pb2.SampleVector()
def _vect_to_string(self, p_mx_vect): l_vec = variables_pb2.SampleVector() l_vec.ParseFromString(p_mx_vect) samples = [] for j in range(len(l_vec.samples)): s = l_vec.samples[j] ts = s.timestamp try: strs = [ struct.pack(self._sample_struct_type, ch) for ch in s.channels ] if self._append_ts: strs.append(struct.pack(self._sample_struct_type, ts)) except struct.error: LOGGER.error( "Error while writhing to file. Bad sample format.") raise (signal_exceptions.BadSampleFormat()) samples.append(''.join(strs)) return ''.join(samples)
def handle_message(self, mxmsg): """Internal method, fired every time message is received. Args: mxmsg: message data """ if mxmsg.type == types.AMPLIFIER_SIGNAL_MESSAGE: # we have received part of the signal data = variables_pb2.SampleVector() data.ParseFromString(mxmsg.message) self.buffer.handle_sample_vect(data) elif mxmsg.type == types.BLINK_MESSAGE: # we have received a single blink data = variables_pb2.Blink() data.ParseFromString(mxmsg.message) self.buffer.handle_blink(data) else: self.logger.warning("Got unrecognised message type: " + str(mxmsg.type)) self.no_response()
def __init__(self, url, peer, samples_per_packet=4): super(EtrWebSocketClient, self).__init__(url, ) self.peer = peer self.samples_per_packet = samples_per_packet self.msg_vector = variables_pb2.SampleVector()