def load_buttons(self): self.lista_sensores_button = [] for i in range(len(self.sensores)): self.sensor = self.sensores[i] log.debug('agregando boton para : ' + self.sensor) #radio_tool_button = 0 radio_tool_button = RadioToolButton(group=self.time) icono = self.sensor.strip('0123456789:') radio_tool_button.set_named_icon(icono) radio_tool_button.set_tooltip(_(self.sensor)) if self.sensor.count('temp'): #determino el numero de sensor y lo paso por parametro. #log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) ) radio_tool_button.connect('clicked', self.click_temp_button, self.get_sensor_number(self.sensor)) elif self.sensor.count('dist'): #log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) ) radio_tool_button.connect('clicked', self.click_dist_button, self.get_sensor_number(self.sensor)) elif self.sensor.count('grey'): #log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) ) radio_tool_button.connect('clicked', self.click_grises_button, self.get_sensor_number(self.sensor)) elif self.sensor.count('light'): #log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) ) radio_tool_button.connect('clicked', self.click_luz_button, self.get_sensor_number(self.sensor)) self.insert(radio_tool_button, 2) self.lista_sensores_button.append(radio_tool_button)
def __init__(self, owner): gtk.Toolbar.__init__(self) self.owner = owner self._insert_separator(True) self.desktop = [] btn = RadioToolButton(group=None) btn.set_named_icon('jam-preset1') btn.connect('toggled', self.setDesktop, 0) btn.set_tooltip(_('Desktop 1')) self.insert(btn, -1) self.desktop.append(btn) for i in range(2, 11): btn = RadioToolButton(group=self.desktop[0]) btn.set_named_icon('jam-preset%d' % i) btn.connect('toggled', self.setDesktop, i - 1) btn.set_tooltip(_('Desktop %d' % i)) self.insert(btn, -1) self.desktop.append(btn) self._insert_separator(True) self.show_all()
def __init__(self, owner): gtk.Toolbar.__init__(self) self.owner = owner self.toolItem = {} self.blockBeat = False self.beatWheel = [] btn = RadioToolButton(group=None) btn.set_named_icon('beats') btn.connect('toggled', self.setBeat, 0) btn.set_tooltip(_('Jump To Beat')) self.insert(btn, -1) self.beatWheel.append(btn) for i in range(1, 12): btn = RadioToolButton(group=self.beatWheel[0]) btn.set_named_icon('beats') btn.connect('toggled', self.setBeat, i) btn.set_tooltip(_('Jump To Beat')) self.insert(btn, -1) self.beatWheel.append(btn) label = gtk.Label(_("Synch to:")) self.syncLabel = gtk.ToolItem() self.syncLabel.add(label) self.insert(self.syncLabel, 0) self.comboBox = ComboBox() self.comboBox.append_item(1, _("1 Beat")) self.comboBox.append_item(2, _("2 Beats")) self.comboBox.append_item(3, _("3 Beats")) self.comboBox.append_item(4, _("4 Beats")) self.comboBox.append_item(5, _("5 Beats")) self.comboBox.append_item(6, _("6 Beats")) self.comboBox.append_item(7, _("7 Beats")) self.comboBox.append_item(8, _("8 Beats")) self.comboBox.append_item(9, _("9 Beats")) self.comboBox.append_item(10, _("10 Beats")) self.comboBox.append_item(11, _("11 Beats")) self.comboBox.append_item(12, _("12 Beats")) self.comboBox.set_active(4 - 1) # default 4 beats self.comboBox.connect("changed", self.changeSync) self.syncBox = ToolComboBox(self.comboBox) self.insert(self.syncBox, 1) self.show_all()
def _radio_button_factory(name='', toolbar=None, cb=None, arg=None, tooltip=None, group=None): ''' Add a radio button to a toolbar ''' button = RadioToolButton(group=group) button.set_named_icon(name) if cb is not None: if arg is None: button.connect('clicked', cb) else: button.connect('clicked', cb, arg) if toolbar is not None: toolbar.insert(button, -1) button.show() if tooltip is not None: button.set_tooltip(tooltip) return button
def radio_factory(button_name, toolbar, callback, cb_arg=None, tooltip=None, group=None): ''' Add a radio button to a toolbar ''' button = RadioToolButton(group=group) button.set_named_icon(button_name) if callback is not None: if cb_arg is None: button.connect('clicked', callback) else: button.connect('clicked', callback, cb_arg) if hasattr(toolbar, 'insert'): # Add button to the main toolbar... toolbar.insert(button, -1) else: # ...or a secondary toolbar. toolbar.props.page.insert(button, -1) button.show() if tooltip is not None: button.set_tooltip(tooltip) return button
class RadioItem(ToggleItem): def __init__(self, group, default_value=True, stock_id=None, important=False): ToggleItem.__init__(self, default_value, stock_id, important) self.group = group def get_tool_item(self): self.toolitem = RadioToolButton() if self.group: self.toolitem.set_group(self.group.toolitem) self.toolitem.set_named_icon( stock.icons[self._stock_id] if self._stock_id in stock.icons else self._stock_id) self.toolitem.set_active(self.default_value) self.toolitem.connect('toggled', self.toggled_cb) self.setup_tooltip() return self.toolitem
def load_buttons(self): self.sensores = [_('Light Sensor'), _('Distance Sensor'), _('Grey Sensor'), _('Button Sensor'), _('Sound Sensor')] self.lista_sensores_button = [] for i in range(len(self.sensores)): self.sensor = self.sensores[i] radio_tool_button = RadioToolButton(group=self.time) icono = self.sensor.strip('0123456789:') radio_tool_button.set_named_icon(icono) radio_tool_button.set_tooltip(_(self.sensor)) if self.sensor.count(_('Sound Sensor')): radio_tool_button.connect('clicked',self.click_sound_button) if self.sensor.count(_('Distance Sensor')): radio_tool_button.connect('clicked',self.click_dist_button) elif self.sensor.count(_('Grey Sensor')): radio_tool_button.connect('clicked',self.click_grises_button) elif self.sensor.count(_('Button Sensor')): radio_tool_button.connect('clicked',self.click_button) log.debug(self.sensores) elif self.sensor.count(_('Light sensor')): radio_tool_button.connect('clicked',self.click_luz_button) self.insert(radio_tool_button, 2) self.lista_sensores_button.append(radio_tool_button)
class SensorToolbar(gtk.Toolbar): ''' The toolbar for specifiying the sensor: sound, resitance, or voltage ''' LOWER = 0.0 UPPER = 1.0 STR_DC_R = \ _("Resistive sensor (connect sensor to pink 'Mic In' on left side \ of XO)" ) + ' ' STR_DC_V = \ _("Voltage sensor (connect sensor to pink 'Mic In' on left side \ of XO)" ) + ' ' STR_AC = _('Sound') + ' ' STR_RESISTANCE = _('Resistance') + ' (' + _('Ohms') + ') ' STR_VOLTAGE = _('Voltage') + ' (' + _('Volts') + ') ' STR_TIME = _('Time Base') + ' ' STR_FREQUENCY = _('Frequency Base') + ' ' STR_INVERT = ' ' + _('Invert') + ' ' STR_XAXIS_TEXT = _('X Axis Scale: 1 division = %(division)s %(unit)s') # TRANSLATORS: This is milli seconds. MS = _('ms') # TRANSLATORS: This is Hertz, so 1/second. HZ = _('Hz') def __init__(self, activity, channels): ''' By default, start with resistance mode ''' gtk.Toolbar.__init__(self) self.activity = activity self._channels = channels self._lock_radio_buttons = False self._radio_button_pushed = False self.values = [] for i in range(self._channels): self.values.append('') self.string_for_textbox = '' self.gain = 1.0 self.y_mag = 3.0 self.capture_gain = CAPTURE_GAIN self.mic_boost = MIC_BOOST self.mode = 'sound' # Set up Time-domain Button self.time = RadioToolButton(group=None) self.time.set_named_icon('media-audio') self.insert(self.time, -1) self.time.set_tooltip(_('Sound')) self.time.connect('clicked', self.analog_resistance_voltage_mode_cb, 'sound') # Set up Resistance Button self.resistance = RadioToolButton(group=self.time) self.resistance.set_named_icon('resistance') if _is_xo(self.activity.hw): self.insert(self.resistance, -1) self.resistance.show() self.resistance.set_tooltip(_('Resistance Sensor')) self.resistance.connect('clicked', self.analog_resistance_voltage_mode_cb, 'resistance') # Set up Voltage Button self.voltage = RadioToolButton(group=self.time) self.voltage.set_named_icon('voltage') if _is_xo(self.activity.hw): self.insert(self.voltage, -1) self.voltage.set_tooltip(_('Voltage Sensor')) self.voltage.connect('clicked', self.analog_resistance_voltage_mode_cb, 'voltage') separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self._log_interval_combo = ComboBox() self.interval = [ _('1/10 second'), _('1 second'), _('30 seconds'), _('5 minutes'), _('30 minutes') ] if hasattr(self._log_interval_combo, 'set_tooltip_text'): self._log_interval_combo.set_tooltip_text(_('Sampling interval')) self._interval_changed_id = self._log_interval_combo.connect( 'changed', self.log_interval_cb) for i, s in enumerate(self.interval): self._log_interval_combo.append_item(i, s, None) if s == _('1 second'): self._log_interval_combo.set_active(i) self._log_interval_tool = ToolComboBox(self._log_interval_combo) self.insert(self._log_interval_tool, -1) self.logging_interval_status = '1 second' # Set up Logging/Stop Logging Button self._record = ToolButton('media-record') self.insert(self._record, -1) self._record.set_tooltip(_('Start Recording')) self._record.connect('clicked', self.record_control_cb) if self.activity.has_toolbarbox: separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) # Set up Trigger Combo box self.trigger_combo = ComboBox() self.trigger = [_('None'), _('Rising Edge'), _('Falling Edge')] self.trigger_conf = [ self.activity.wave.TRIGGER_NONE, self.activity.wave.TRIGGER_POS, self.activity.wave.TRIGGER_NEG ] self._trigger_changed_id = self.trigger_combo.connect( 'changed', self.update_trigger_control) for i, s in enumerate(self.trigger): self.trigger_combo.append_item(i, s, None) self.trigger_combo.set_active(0) if hasattr(self.trigger_combo, 'set_tooltip_text'): self.trigger_combo.set_tooltip_text(_('Create a trigger')) self._trigger_tool = ToolComboBox(self.trigger_combo) self.insert(self._trigger_tool, -1) self.show_all() def add_frequency_slider(self, toolbar): ''' Either on the Sound toolbar or the Main toolbar ''' self._freq_stepper_up = ToolButton('freq-high') self._freq_stepper_up.set_tooltip(_('Zoom out')) self._freq_stepper_up.connect('clicked', self._freq_stepper_up_cb) self.activity.adjustmentf = gtk.Adjustment(0.5, self.LOWER, self.UPPER, 0.01, 0.1, 0) self.activity.adjustmentf.connect('value_changed', self.cb_page_sizef) self._freq_range = gtk.HScale(self.activity.adjustmentf) self._freq_range.set_inverted(True) self._freq_range.set_draw_value(False) self._freq_range.set_update_policy(gtk.UPDATE_CONTINUOUS) self._freq_range.set_size_request(120, 15) self._freq_stepper_down = ToolButton('freq-low') self._freq_stepper_down.set_tooltip(_('Zoom in')) self._freq_stepper_down.connect('clicked', self._freq_stepper_down_cb) self._freq_range_tool = gtk.ToolItem() self._freq_range_tool.add(self._freq_range) toolbar.insert(self._freq_stepper_up, -1) toolbar.insert(self._freq_range_tool, -1) toolbar.insert(self._freq_stepper_down, -1) return def update_trigger_control(self, *args): ''' Callback for trigger control ''' if self.activity.wave.get_fft_mode(): self.trigger_combo.set_active(self.activity.wave.TRIGGER_NONE) active = self.trigger_combo.get_active() if active == -1: return self.activity.wave.set_trigger(self.trigger_conf[active]) return def analog_resistance_voltage_mode_cb(self, button=None, mode_to_set='sound'): ''' Callback for Analog/Resistance/Voltage Buttons ''' if self._lock_radio_buttons: logging.debug('mode selector locked') self._radio_button_pushed = True return if self.mode == mode_to_set: logging.debug('mode already set to %s' % mode_to_set) return self._lock_radio_buttons = True if self.activity.CONTEXT == 'sound': self.sound_context_off() else: self.sensor_context_off() # Force time domain when switching modes if self.activity.wave.get_fft_mode(): self.activity.timefreq_control() # Turn off logging when switching modes if self.activity.audiograb.we_are_logging: self.record_control_cb() self.set_mode(mode_to_set) if mode_to_set == 'sound': self.set_sound_context() elif mode_to_set == 'resistance': self.set_sensor_context() elif mode_to_set == 'voltage': self.set_sensor_context() self.update_string_for_textbox() return False def unlock_radio_buttons(self): ''' Enable radio button selection ''' logging.debug('unlocking radio buttons') if self._radio_button_pushed: if self.mode == 'sound': self.time.set_active(True) elif self.mode == 'resistance': self.resistance.set_active(True) elif self.mode == 'voltage': self.voltage.set_active(True) self._lock_radio_buttons = False self._radio_button_pushed = False def set_mode(self, mode='sound'): ''' Set the mixer settings to match the current mode. ''' self.mode = mode self.activity.audiograb.set_sensor_type(self.mode) for i in range(self._channels): self.values[i] = 0.0 return def get_mode(self): ''' Get the mixer settings. ''' return self.mode def _freq_stepper_up_cb(self, button=None): ''' Moves the horizontal zoom slider to the left one notch, where one notch is 1/100 of the total range. This correspond to zooming out as a larger number of Hertz or milliseconds will be represented by the same space on the screen. ''' new_value = self._freq_range.get_value() +\ (self.UPPER - self.LOWER) / 100.0 if new_value <= self.UPPER: self._freq_range.set_value(new_value) else: self._freq_range.set_value(self.UPPER) def _freq_stepper_down_cb(self, button=None): ''' Moves the horizontal zoom slider to the right one notch, where one notch is 1/100 of the total range. This corresponds to zooming in. ''' new_value = self._freq_range.get_value() -\ (self.UPPER - self.LOWER) / 100.0 if new_value >= self.LOWER: self._freq_range.set_value(new_value) else: self._freq_range.set_value(self.LOWER) def cb_page_sizef(self, button=None): ''' Callback to scale the frequency range (zoom in and out) ''' if self._update_page_size_id: gobject.source_remove(self._update_page_size_id) self._update_page_size_id =\ gobject.timeout_add(250, self.update_page_size) return True def update_page_size(self): ''' Set up the scaling of the display. ''' self._update_page_size_id = None new_value = round(self.activity.adjustmentf.value * 100.0) / 100.0 if self.activity.adjustmentf.value != new_value: self.activity.adjustmentf.value = new_value return False time_div = 0.001 * max(self.activity.adjustmentf.value, 0.05) freq_div = 1000 * max(self.activity.adjustmentf.value, 0.01) self.activity.wave.set_div(time_div, freq_div) self.update_string_for_textbox() return False def set_sound_context(self): ''' Called when analog sensing is selected ''' self.set_show_hide_windows(mode='sound') gobject.timeout_add(500, self.sound_context_on) self.activity.CONTEXT = 'sound' def set_sensor_context(self): ''' Called when digital sensing is selected ''' self.set_show_hide_windows(mode='sensor') gobject.timeout_add(500, self.sensor_context_on) self.activity.CONTEXT = 'sensor' def set_show_hide_windows(self, mode='sound'): ''' Shows the appropriate window identified by the mode ''' self.activity.wave.set_context_on() for i in range(self._channels): self.activity.side_toolbars[i].set_show_hide(True, mode) def sensor_context_off(self): ''' Called when a DC sensor is no longer selected ''' # self.activity.audiograb.pause_grabbing() self.activity.audiograb.stop_grabbing() def sensor_context_on(self): ''' Called when a DC sensor is selected ''' self.update_string_for_textbox() self.activity.wave.set_trigger(self.activity.wave.TRIGGER_NONE) # self.activity.audiograb.resume_grabbing() self.activity.audiograb.start_grabbing() return False def sound_context_off(self): ''' Called when an analog sensor is no longer selected ''' self.gain, self.y_mag = self.activity.wave.get_mag_params() self.capture_gain = self.activity.audiograb.get_capture_gain() self.mic_boost = self.activity.audiograb.get_mic_boost() self.activity.audiograb.stop_grabbing() def sound_context_on(self): ''' Called when an analog sensor is selected ''' self.activity.wave.set_mag_params(self.gain, self.y_mag) self.update_string_for_textbox() self.update_trigger_control() self.activity.audiograb.start_grabbing() return False def set_sample_value(self, value='', channel=0): ''' Write a sample value to the textbox. ''' gtk.threads_enter() self.values[channel] = value self.update_string_for_textbox() gtk.threads_leave() return def record_control_cb(self, button=None): ''' Depending upon the selected interval, does either a logging session, or just logs the current buffer. ''' if self.activity.audiograb.we_are_logging: self.activity.audiograb.set_logging_params(start_stop=False) self._record.set_icon('media-record') self._record.show() self._record.set_tooltip(_('Start Recording')) else: Xscale = (1.00 / self.activity.audiograb.get_sampling_rate()) Yscale = 0.0 interval = self.interval_convert() username = self.activity.nick if self.activity.wave.get_fft_mode(): self.activity.data_logger.start_new_session( username, Xscale, Yscale, _(self.logging_interval_status), channels=self._channels, mode='frequency') else: self.activity.data_logger.start_new_session( username, Xscale, Yscale, _(self.logging_interval_status), channels=self._channels, mode=self.mode) self.activity.audiograb.set_logging_params(start_stop=True, interval=interval, screenshot=False) self._record.set_icon('record-stop') self._record.show() self._record.set_tooltip(_('Stop Recording')) self.activity.new_recording = True def interval_convert(self): ''' Converts interval string to an integer that denotes the number of times the audiograb buffer must be called before a value is written. When set to 0, the whole of current buffer will be written. ''' interval_dictionary = { '1/10 second': 0.1, '1 second': 1, '30 seconds': 30, '5 minutes': 300, '30 minutes': 1800 } try: return interval_dictionary[self.logging_interval_status] except ValueError: logging.error('logging interval status = %s' %\ (str(self.logging_interval_status))) return 0 def log_interval_cb(self, combobox): ''' Callback from the Logging Interval Combo box: sets status ''' if self._log_interval_combo.get_active() != -1: intervals = [ '1/10 second', '1 second', '30 seconds', '5 minutes', '30 minutes' ] self.logging_interval_status = \ intervals[self._log_interval_combo.get_active()] def update_string_for_textbox(self): ''' Update the status field at the bottom of the canvas. ''' if self.activity.CONTEXT == 'butia': string_for_textbox = '' else: if self.mode == 'resistance': string_for_textbox = (self.STR_DC_R + '\n') string_for_textbox += self.STR_RESISTANCE elif self.mode == 'voltage': string_for_textbox = (self.STR_DC_V + '\n') string_for_textbox += self.STR_VOLTAGE else: string_for_textbox = (self.STR_AC + '\t') if self.activity.wave.get_fft_mode(): scalex = self.STR_XAXIS_TEXT % { 'unit': self.HZ, 'division': self.activity.wave.freq_div } string_for_textbox += self.STR_FREQUENCY string_for_textbox += ('\n' + scalex) elif self.mode == 'sound': scalex = self.STR_XAXIS_TEXT % { 'unit': self.MS, 'division': self.activity.wave.time_div * 1000 } string_for_textbox += self.STR_TIME string_for_textbox += ('\n' + scalex) else: for i in range(self._channels): string_for_textbox += '\t(%s)' % (self.values[i]) invert = False for i in range(self._channels): if self.activity.wave.get_invert_state(channel=i): invert = True if invert: string_for_textbox += self.STR_INVERT self.activity.text_box.set_label(string_for_textbox)
class ArduinoToolbar(gtk.Toolbar): ''' The toolbar for specifiying the sensor: temp, distance, light or gray ''' def __init__(self, activity, channels): self._arduino_context_id = None gtk.Toolbar.__init__(self) self.activity = activity self._channels = channels self.mode = 'arduino' # Set up Sensores Button self.time = RadioToolButton(group=None) self.lista_sensores_button = [] self.we_are_logging = False self._log_this_sample = False self._logging_timer = None self._logging_counter = 0 self._image_counter = 0 self._logging_interval = 0 self._channels_logged = [] self._busy = False self._take_screenshot = True log.debug('se agrega el boton refrescar') self.refrescar_button = RadioToolButton(group=None) self.refrescar_button.set_named_icon('recargar') self.refrescar_button.connect('clicked', self.click_refresh_button) self.insert(self.refrescar_button, -1) separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self.robot = Arduino() self._port_entry = gtk.Entry() self._port_entry.set_text('A5') # A self._port_entry_changed_id = self._port_entry.connect( 'changed', self._read_sensor) if hasattr(self._port_entry, 'set_tooltip_text'): self._port_entry.set_tooltip_text(_('Enter a port to read.')) self._port_entry.set_width_chars(2) self._port_entry.show() toolitem = gtk.ToolItem() toolitem.add(self._port_entry) self.insert(toolitem, -1) toolitem.show() separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self._log_value = LOG_TIMER_VALUES[1] self.log_label = gtk.Label(self._log_to_string(self._log_value)) toolitem = gtk.ToolItem() toolitem.add(self.log_label) self.insert(toolitem, -1) self._log_button = ToolButton('timer-10') self._log_button.set_tooltip(_('Select logging interval')) self._log_button.connect('clicked', self._log_selection_cb) self.insert(self._log_button, -1) self._setup_log_palette() # Set up Logging/Stop Logging Button self._record = ToolButton('media-record') self.insert(self._record, -1) self._record.set_tooltip(_('Start Recording')) self._record.connect('clicked', self.record_control_cb) self.show_all() def get_log(self): return self._log_value def get_log_idx(self): if self._log_value in LOG_TIMER_VALUES: return LOG_TIMER_VALUES.index(self._log_value) else: return LOG_TIMER_VALUES[0] def set_log_idx(self, idx): self._log_value = LOG_TIMER_VALUES[idx] self.log_label.set_text(self._log_to_string(self._log_value)) if hasattr(self, '_log_button'): self._log_button.set_icon('timer-%d' % (self._log_value)) def _log_selection_cb(self, widget): if self._log_palette: if not self._log_palette.is_up(): self._log_palette.popup(immediate=True, state=self._log_palette.SECONDARY) else: self._log_palette.popdown(immediate=True) return def _log_to_seconds(self, tenth_seconds): return tenth_seconds / 10. def _log_to_string(self, tenth_seconds): if tenth_seconds in LOG_TIMER_LABELS: return LOG_TIMER_LABELS[tenth_seconds] else: return _('1 second') def _setup_log_palette(self): self._log_palette = self._log_button.get_palette() for tenth_seconds in LOG_TIMER_VALUES: text = self._log_to_string(tenth_seconds) menu_item = MenuItem(icon_name='timer-%d' % (tenth_seconds), text_label=self._log_to_string(tenth_seconds)) menu_item.connect('activate', self._log_selected_cb, tenth_seconds) self._log_palette.menu.append(menu_item) menu_item.show() def _log_selected_cb(self, button, seconds): self.set_log_idx(LOG_TIMER_VALUES.index(seconds)) def get_port(self): return self._port_value def get_port_idx(self): if self._port_value in PORT_VALUES: return PORT_VALUES.index(self._port_value) else: return PORT_VALUES[0] def set_port_idx(self, idx): self._port_value = PORT_VALUES[idx] self.port_label.set_text(self._port_to_string(self._port_value)) if hasattr(self, '_port_button'): self._port_button.set_icon('arduino-tools') def _port_selection_cb(self, widget): if self._port_palette: if not self._port_palette.is_up(): self._port_palette.popup(immediate=True, state=self._port_palette.SECONDARY) else: self._port_palette.popdown(immediate=True) return def _port_to_string(self, tenth_seconds): if tenth_seconds in PORT_LABELS: return PORT_LABELS[tenth_seconds] else: return _('1 second') def _setup_port_palette(self): self._port_palette = self._port_button.get_palette() for tenth_seconds in PORT_VALUES: text = self._port_to_string(tenth_seconds) menu_item = MenuItem( icon_name='arduino-tools', text_label=self._port_to_string(tenth_seconds)) menu_item.connect('activate', self._port_selected_cb, tenth_seconds) self._port_palette.menu.append(menu_item) menu_item.show() def _port_selected_cb(self, button, seconds): self.set_port_idx(PORT_VALUES.index(seconds)) def read_sensor_from_bobot_server(self): log.debug('**********Read Sensor ***********') return 0 def click_refresh_button(self, event=None): log.debug('********** clickea botton refresh ***********') self.robot.refresh() self.mode = 'reading' self.read_sensor_from_bobot_server = self._read_sensor self.activity.limpiar_canales() self.set_arduino_context() return False def _port_entry_cb(self, event=None): log.debug('********** port_changed ***********') self.robot.refresh() self.mode = 'reading' self.read_sensor_from_bobot_server = self._read_sensor self.activity.limpiar_canales() self.set_arduino_context() return False def set_arduino_context(self): self.activity.audiograb.stop_grabbing() if self._arduino_context_id: gobject.source_remove(self._arduino_context_id) self._arduino_context_id =\ gobject.timeout_add(50,self.arduino_context_on) def arduino_context_on(self): bufChannelTmp = [] #Si esta el boton de pause activada no se agregar el nuevo valor if self.activity.audiograb.get_freeze_the_display(): bufChannelTmp.append(self.read_sensor_from_bobot_server()) for i in range(self.activity.audiograb.channels): self.activity.wave.new_buffer(bufChannelTmp, i) if self.we_are_logging: self.logging_to_file(bufChannelTmp, i) #if self.activity.CONTEXT == 'arduino': return True #else: #return False def logging_to_file(self, data_buffer, channel): if self.we_are_logging: if self._logging_counter == MAX_LOG_ENTRIES: self._logging_counter = 0 self.we_are_logging = False self.activity.data_logger.stop_session() else: if self._logging_interval == 0: self._emit_for_logging(data_buffer, channel=channel) self._log_this_sample = False self.we_are_logging = False self.activity.data_logger.stop_session() elif self._log_this_sample: # Sample channels in order if self.activity.audiograb._channels_logged.index( False) == channel: self.activity.audiograb._channels_logged[ channel] = True self._emit_for_logging(data_buffer, channel=channel) # Have we logged every channel? if self.activity.audiograb._channels_logged.count( True) == self.activity.audiograb.channels: self._log_this_sample = False for i in range(self.activity.audiograb.channels): self.activity.audiograb._channels_logged[ i] = False self._logging_counter += 1 def _emit_for_logging(self, data_buffer, channel=0): '''Sends the data for logging''' if not self._busy: self._busy = True if self._take_screenshot: if self.activity.data_logger.take_screenshot( self._image_counter): self._image_counter += 1 else: log.debug('failed to take screenshot %d' % (self._logging_counter)) self._busy = False return value_string = data_buffer[0] if self.activity.audiograb.channels > 1: self.activity.data_logger.write_value( value_string, channel=channel, sample=self._logging_counter) else: self.activity.data_logger.write_value( value_string, sample=self._logging_counter) self._busy = False else: log.debug('skipping sample %d.%d' % (self._logging_counter, channel)) def _sample_now(self): ''' Log the current sample now. This method is called from the _logging_timer object when the interval expires. ''' self._log_this_sample = True self._make_timer() def _make_timer(self): ''' Create the next timer that will trigger data logging. ''' self._logging_timer = Timer(self._logging_interval, self._sample_now) self._logging_timer.start() def record_control_cb(self, button=None): ''' Depending upon the selected interval, does either a logging session, or just logs the current buffer. ''' if self.we_are_logging: self.set_logging_params(start_stop=False) self._record.set_icon('media-record') self._record.show() self._record.set_tooltip(_('Start Recording')) else: Xscale = 0.0 Yscale = 0.0 interval = self.interval_convert() username = self.activity.nick if self.activity.wave.get_fft_mode(): self.activity.data_logger.start_new_session( username, Xscale, Yscale, _(self.logging_interval_status), channels=self._channels, mode='frequency') else: self.activity.data_logger.start_new_session( username, Xscale, Yscale, _(self.logging_interval_status), channels=self._channels, mode=self.mode) self.set_logging_params(start_stop=True, interval=interval, screenshot=False) self._record.set_icon('record-stop') self._record.show() self._record.set_tooltip(_('Stop Recording')) self.activity.new_recording = True def set_logging_params(self, start_stop=False, interval=0, screenshot=True): ''' Configures for logging of data: starts or stops a session; sets the logging interval; and flags if screenshot is taken. ''' self.we_are_logging = start_stop self._logging_interval = interval if not start_stop: if self._logging_timer: self._logging_timer.cancel() self._logging_timer = None self._log_this_sample = False self._logging_counter = 0 elif interval != 0: self._make_timer() self._take_screenshot = screenshot self._busy = False def interval_convert(self): ''' Converts interval string to an integer that denotes the number of times the audiograb buffer must be called before a value is written. When set to 0, the whole of current buffer will be written. ''' interval_dictionary = { '1/10 second': 0.1, '1 second': 1, '30 seconds': 30, '5 minutes': 300, '30 minutes': 1800 } try: return interval_dictionary[self.logging_interval_status] except ValueError: logging.error('logging interval status = %s' %\ (str(self.logging_interval_status))) return 0 def take_screenshot(self): ''' Capture the current screen to the Journal ''' log.debug('taking a screenshot %d' % (self._logging_counter)) self.set_logging_params(start_stop=True, interval=0, screenshot=True) def _read_sensor(self, event=None): port = self._port_entry.get_text() if port.count('A'): log.debug('analogRead') value = self.robot.analogRead(port.strip('A')) else: log.debug('digitalRead') self.robot.pinMode(port, _('INPUT')) value = self.robot.digitalRead(port) log.debug('VALOR A DEVOLVER') value *= 1000 log.debug(value) gtk.gdk.flush() return value
class SensorToolbar(gtk.Toolbar): """ The toolbar for specifiying the sensor: sound, resitance, or voltage """ LOWER = 0.0 UPPER = 1.0 STR_DC_R = ( _( "Resistive sensor (connect sensor to pink 'Mic In' on left side \ of XO)" ) + " " ) STR_DC_V = ( _( "Voltage sensor (connect sensor to pink 'Mic In' on left side \ of XO)" ) + " " ) STR_AC = _("Sound") + " " STR_RESISTANCE = _("Resistance") + " (" + _("Ohms") + ") " STR_VOLTAGE = _("Voltage") + " (" + _("Volts") + ") " STR_TIME = _("Time Base") + " " STR_FREQUENCY = _("Frequency Base") + " " STR_INVERT = " " + _("Invert") + " " STR_XAXIS_TEXT = _("X Axis Scale: 1 division = %(division)s %(unit)s") # TRANSLATORS: This is milli seconds. MS = _("ms") # TRANSLATORS: This is Hertz, so 1/second. HZ = _("Hz") def __init__(self, activity, channels): """ By default, start with resistance mode """ gtk.Toolbar.__init__(self) self.activity = activity self._channels = channels self._lock_radio_buttons = False self._radio_button_pushed = False self.values = [] for i in range(self._channels): self.values.append("") self.string_for_textbox = "" self.gain = 1.0 self.y_mag = 3.0 self.capture_gain = CAPTURE_GAIN self.mic_boost = MIC_BOOST self.mode = "sound" # Set up Time-domain Button self.time = RadioToolButton(group=None) self.time.set_named_icon("media-audio") self.insert(self.time, -1) self.time.set_tooltip(_("Sound")) self.time.connect("clicked", self.analog_resistance_voltage_mode_cb, "sound") # Set up Resistance Button self.resistance = RadioToolButton(group=self.time) self.resistance.set_named_icon("resistance") if _is_xo(self.activity.hw): self.insert(self.resistance, -1) self.resistance.show() self.resistance.set_tooltip(_("Resistance Sensor")) self.resistance.connect("clicked", self.analog_resistance_voltage_mode_cb, "resistance") # Set up Voltage Button self.voltage = RadioToolButton(group=self.time) self.voltage.set_named_icon("voltage") if _is_xo(self.activity.hw): self.insert(self.voltage, -1) self.voltage.set_tooltip(_("Voltage Sensor")) self.voltage.connect("clicked", self.analog_resistance_voltage_mode_cb, "voltage") separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self._log_value = LOG_TIMER_VALUES[1] self.log_label = gtk.Label(self._log_to_string(self._log_value)) toolitem = gtk.ToolItem() toolitem.add(self.log_label) self.insert(toolitem, -1) self._log_button = ToolButton("timer-10") self._log_button.set_tooltip(_("Select logging interval")) self._log_button.connect("clicked", self._log_selection_cb) self.insert(self._log_button, -1) self._setup_log_palette() # Set up Logging/Stop Logging Button self._record = ToolButton("media-record") self.insert(self._record, -1) self._record.set_tooltip(_("Start logging")) self._record.connect("clicked", self.record_control_cb) separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) toolitem = gtk.ToolItem() self.trigger_label = gtk.Label(_("Trigger")) toolitem.add(self.trigger_label) self.insert(toolitem, -1) # Set up Trigger Combo box self.trigger_none = RadioToolButton() self.trigger_none.set_named_icon("trigger-none") self.insert(self.trigger_none, -1) self.trigger_none.set_tooltip(_("None")) self.trigger_none.connect("clicked", self.update_trigger_control_cb, self.activity.wave.TRIGGER_NONE) self.trigger_rise = RadioToolButton(group=self.trigger_none) self.trigger_rise.set_named_icon("trigger-rise") self.insert(self.trigger_rise, -1) self.trigger_rise.set_tooltip(_("Rising Edge")) self.trigger_rise.connect("clicked", self.update_trigger_control_cb, self.activity.wave.TRIGGER_POS) self.trigger_fall = RadioToolButton(group=self.trigger_none) self.trigger_fall.set_named_icon("trigger-fall") self.insert(self.trigger_fall, -1) self.trigger_fall.set_tooltip(_("Falling Edge")) self.trigger_fall.connect("clicked", self.update_trigger_control_cb, self.activity.wave.TRIGGER_NEG) self.show_all() def get_log(self): return self._log_value def get_log_idx(self): if self._log_value in LOG_TIMER_VALUES: return LOG_TIMER_VALUES.index(self._log_value) else: return LOG_TIMER_VALUES[0] def set_log_idx(self, idx): self._log_value = LOG_TIMER_VALUES[idx] self.log_label.set_text(self._log_to_string(self._log_value)) if hasattr(self, "_log_button"): self._log_button.set_icon("timer-%d" % (self._log_value)) def _log_selection_cb(self, widget): if self._log_palette: if not self._log_palette.is_up(): self._log_palette.popup(immediate=True, state=self._log_palette.SECONDARY) else: self._log_palette.popdown(immediate=True) return def _log_to_seconds(self, tenth_seconds): return tenth_seconds / 10.0 def _log_to_string(self, tenth_seconds): if tenth_seconds in LOG_TIMER_LABELS: return LOG_TIMER_LABELS[tenth_seconds] else: return _("1 second") def _setup_log_palette(self): self._log_palette = self._log_button.get_palette() for tenth_seconds in LOG_TIMER_VALUES: text = self._log_to_string(tenth_seconds) menu_item = MenuItem(icon_name="timer-%d" % (tenth_seconds), text_label=self._log_to_string(tenth_seconds)) menu_item.connect("activate", self._log_selected_cb, tenth_seconds) self._log_palette.menu.append(menu_item) menu_item.show() def _log_selected_cb(self, button, seconds): self.set_log_idx(LOG_TIMER_VALUES.index(seconds)) def add_frequency_slider(self, toolbox): """ Either on the Sound toolbar or the Main toolbar """ self._freq_stepper_up = ToolButton("freq-high") self._freq_stepper_up.set_tooltip(_("Zoom out")) self._freq_stepper_up.connect("clicked", self._freq_stepper_up_cb) self._freq_stepper_up.show() self.activity.adjustmentf = gtk.Adjustment(0.5, self.LOWER, self.UPPER, 0.01, 0.1, 0) self.activity.adjustmentf.connect("value_changed", self.cb_page_sizef) self._freq_range = gtk.HScale(self.activity.adjustmentf) self._freq_range.set_inverted(True) self._freq_range.set_draw_value(False) self._freq_range.set_update_policy(gtk.UPDATE_CONTINUOUS) self._freq_range.set_size_request(120, 15) self._freq_range.show() self._freq_stepper_down = ToolButton("freq-low") self._freq_stepper_down.set_tooltip(_("Zoom in")) self._freq_stepper_down.connect("clicked", self._freq_stepper_down_cb) self._freq_stepper_down.show() self._freq_range_tool = gtk.ToolItem() self._freq_range_tool.add(self._freq_range) self._freq_range_tool.show() toolbox.add(self._freq_stepper_up) toolbox.add(self._freq_range_tool) toolbox.add(self._freq_stepper_down) return def update_trigger_control_cb(self, button, value): if button is None: value = self.activity.wave.TRIGGER_NONE if self.activity.wave.get_fft_mode(): self.trigger_none.set_active(True) else: self.activity.wave.set_trigger(value) def analog_resistance_voltage_mode_cb(self, button=None, mode_to_set="sound"): """ Callback for Analog/Resistance/Voltage Buttons """ if self._lock_radio_buttons: logging.debug("mode selector locked") self._radio_button_pushed = True return if self.mode == mode_to_set: logging.debug("mode already set to %s" % mode_to_set) return self._lock_radio_buttons = True if self.activity.CONTEXT == "sound": self.sound_context_off() else: self.sensor_context_off() # Force time domain when switching modes if self.activity.wave.get_fft_mode(): self.activity.timefreq_control() # Turn off logging when switching modes if self.activity.audiograb.we_are_logging: self.record_control_cb() self.set_mode(mode_to_set) if mode_to_set == "sound": self.set_sound_context() elif mode_to_set == "resistance": self.set_sensor_context() elif mode_to_set == "voltage": self.set_sensor_context() self.update_string_for_textbox() return False def unlock_radio_buttons(self): """ Enable radio button selection """ logging.debug("unlocking radio buttons") if self._radio_button_pushed: if self.mode == "sound": self.time.set_active(True) elif self.mode == "resistance": self.resistance.set_active(True) elif self.mode == "voltage": self.voltage.set_active(True) self._lock_radio_buttons = False self._radio_button_pushed = False def set_mode(self, mode="sound"): """ Set the mixer settings to match the current mode. """ self.mode = mode self.activity.audiograb.set_sensor_type(self.mode) for i in range(self._channels): self.values[i] = 0.0 return def get_mode(self): """ Get the mixer settings. """ return self.mode def _freq_stepper_up_cb(self, button=None): """ Moves the horizontal zoom slider to the left one notch, where one notch is 1/100 of the total range. This correspond to zooming out as a larger number of Hertz or milliseconds will be represented by the same space on the screen. """ new_value = self._freq_range.get_value() + (self.UPPER - self.LOWER) / 100.0 if new_value <= self.UPPER: self._freq_range.set_value(new_value) else: self._freq_range.set_value(self.UPPER) def _freq_stepper_down_cb(self, button=None): """ Moves the horizontal zoom slider to the right one notch, where one notch is 1/100 of the total range. This corresponds to zooming in. """ new_value = self._freq_range.get_value() - (self.UPPER - self.LOWER) / 100.0 if new_value >= self.LOWER: self._freq_range.set_value(new_value) else: self._freq_range.set_value(self.LOWER) def cb_page_sizef(self, button=None): """ Callback to scale the frequency range (zoom in and out) """ if self._update_page_size_id: gobject.source_remove(self._update_page_size_id) self._update_page_size_id = gobject.timeout_add(250, self.update_page_size) return True def update_page_size(self): """ Set up the scaling of the display. """ self._update_page_size_id = None new_value = round(self.activity.adjustmentf.value * 100.0) / 100.0 if self.activity.adjustmentf.value != new_value: self.activity.adjustmentf.value = new_value return False time_div = 0.001 * max(self.activity.adjustmentf.value, 0.05) freq_div = 1000 * max(self.activity.adjustmentf.value, 0.01) self.activity.wave.set_div(time_div, freq_div) self.update_string_for_textbox() return False def set_sound_context(self): """ Called when analog sensing is selected """ self.set_show_hide_windows(mode="sound") gobject.timeout_add(500, self.sound_context_on) self.activity.CONTEXT = "sound" def set_sensor_context(self): """ Called when digital sensing is selected """ self.set_show_hide_windows(mode="sensor") gobject.timeout_add(500, self.sensor_context_on) self.activity.CONTEXT = "sensor" def set_show_hide_windows(self, mode="sound"): """ Shows the appropriate window identified by the mode """ self.activity.wave.set_context_on() for i in range(self._channels): self.activity.side_toolbars[i].set_show_hide(True, mode) def sensor_context_off(self): """ Called when a DC sensor is no longer selected """ # self.activity.audiograb.pause_grabbing() self.activity.audiograb.stop_grabbing() def sensor_context_on(self): """ Called when a DC sensor is selected """ self.update_string_for_textbox() self.activity.wave.set_trigger(self.activity.wave.TRIGGER_NONE) # self.activity.audiograb.resume_grabbing() self.activity.audiograb.start_grabbing() return False def sound_context_off(self): """ Called when an analog sensor is no longer selected """ self.gain, self.y_mag = self.activity.wave.get_mag_params() self.capture_gain = self.activity.audiograb.get_capture_gain() self.mic_boost = self.activity.audiograb.get_mic_boost() self.activity.audiograb.stop_grabbing() def sound_context_on(self): """ Called when an analog sensor is selected """ self.activity.wave.set_mag_params(self.gain, self.y_mag) self.update_string_for_textbox() self.update_trigger_control_cb(None, self.activity.wave.TRIGGER_NONE) self.activity.audiograb.start_grabbing() return False def set_sample_value(self, value="", channel=0): """ Write a sample value to the textbox. """ gtk.threads_enter() self.values[channel] = value self.update_string_for_textbox() gtk.threads_leave() return def record_control_cb(self, button=None): """ Depending upon the selected interval, does either a logging session, or just logs the current buffer. """ if self.activity.audiograb.we_are_logging: self.activity.audiograb.set_logging_params(start_stop=False) self._record.set_icon("media-record") self._record.show() self._record.set_tooltip(_("Start Recording")) else: Xscale = 1.00 / self.activity.audiograb.get_sampling_rate() Yscale = 0.0 interval = self._log_value / 10.0 # self.interval_convert() username = self.activity.nick if self.activity.wave.get_fft_mode(): self.activity.data_logger.start_new_session( username, Xscale, Yscale, self._log_to_string(self._log_value), channels=self._channels, mode="frequency", ) else: self.activity.data_logger.start_new_session( username, Xscale, Yscale, self._log_to_string(self._log_value), channels=self._channels, mode=self.mode, ) self.activity.audiograb.set_logging_params(start_stop=True, interval=interval, screenshot=False) self._record.set_icon("record-stop") self._record.show() self._record.set_tooltip(_("Stop Recording")) self.activity.new_recording = True def update_string_for_textbox(self): """ Update the status field at the bottom of the canvas. """ if self.mode == "resistance": string_for_textbox = self.STR_DC_R + "\n" string_for_textbox += self.STR_RESISTANCE elif self.mode == "voltage": string_for_textbox = self.STR_DC_V + "\n" string_for_textbox += self.STR_VOLTAGE else: string_for_textbox = self.STR_AC + "\t" if self.activity.wave.get_fft_mode(): scalex = self.STR_XAXIS_TEXT % {"unit": self.HZ, "division": self.activity.wave.freq_div} string_for_textbox += self.STR_FREQUENCY string_for_textbox += "\n" + scalex elif self.mode == "sound": scalex = self.STR_XAXIS_TEXT % {"unit": self.MS, "division": self.activity.wave.time_div * 1000} string_for_textbox += self.STR_TIME string_for_textbox += "\n" + scalex else: for i in range(self._channels): string_for_textbox += "\t(%s)" % (self.values[i]) invert = False for i in range(self._channels): if self.activity.wave.get_invert_state(channel=i): invert = True if invert: string_for_textbox += self.STR_INVERT self.activity.text_box.set_label(string_for_textbox)
def __init__(self, handle): activity.Activity.__init__(self, handle, True) self.max_participants = 1 # ****** Editor ****** self.editor = Editor() self.editor.connect("pep8-aviable", self.enable_pep8) self.editor.connect('language-changed', self.language_changed) self.editor.set_size_request(800, 790) scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scroll.add(self.editor) vbox = gtk.VBox() vpaned = gtk.VPaned() vbox.pack_start(vpaned, True, True, 0) vpaned.show() vpaned.pack1(scroll, resize=True) scroll.show_all() self.set_canvas(vbox) # ****** Toolbars ****** self.toolbar_box = options.OptionWidget(self, self.editor.get_pango_context()) self.toolbar_box.connect('open-from-journal', file_choosers.open_from_journal, None, self) self.toolbar_box.connect('open-file', self.open_file) self.toolbar_box.connect('save-file', self.save_file) self.toolbar_box.connect('save-as', self.save_file_as) self.toolbar_box.connect('new-file', self.new) self.toolbar_box.connect('pep8-check', self.pep8_check) self.toolbar_box.connect('insert-datetime', self.editor._insert_date_time) self.toolbar_box.connect('copy', self.editor._copy_cb) self.toolbar_box.connect('paste', self.editor._paste_cb) self.toolbar_box.connect('undo', self.editor._undo_cb) self.toolbar_box.connect('redo', self.editor._redo_cb) self.toolbar_box.connect('cut', self.editor._cut_cb) self.toolbar_box.connect('search-text', self._search_text) self.toolbar_box.connect('search-prev', self.editor._search_prev_cb) self.toolbar_box.connect('search-next', self.editor._search_next_cb) self.toolbar_box.connect('show-line-numbers', self.editor._set_show_line_numbers) self.toolbar_box.connect('language-changed', self.change_language) self.toolbar_box.connect('style-changed', self.change_style) self.toolbar_box.connect('font-changed', self.change_font) self.toolbar_box.show_all() self.set_toolbar_box(self.toolbar_box) # Barra de estado de PEP8 / PEP8 status bar self.pep8 = PEP8_Check() self.pep8_bar = gtk.Statusbar() self.pep8.connect("show-bar", (lambda w, bar: bar.show_all()), self.pep8_bar) self.pep8.connect("hide-bar", (lambda w, bar: bar.hide()), self.pep8_bar) self.pep8_bar.label = gtk.Label() self.pep8.connect("bar-text", (lambda w, t, l: l.set_text(t)), self.pep8_bar.label) self.pep8_bar.add(self.pep8_bar.label) vbox.pack_end(self.pep8_bar, False, True, 0) tray = VTray() self.test_notebook = gtk.Notebook() self.test_notebook.set_show_tabs(False) terminal = consoles.Terminal() terminal.show() terminal_item = RadioToolButton() terminal_item.set_named_icon("console-terminal") terminal_item.set_tooltip("Terminal") terminal_item.connect("toggled", self.page_changed, 0) terminal_item.show() self.test_notebook.append_page(terminal, None) tray.add_item(terminal_item) python_console = consoles.PythonConsole() python_console.show() python_item = RadioToolButton() python_item.set_named_icon("console-python") python_item.set_tooltip("Python Console") python_item.set_group(terminal_item) python_item.connect("toggled", self.page_changed, 1) python_item.show() self.test_notebook.append_page(python_console) tray.add_item(python_item) hbox = gtk.HBox() hbox.pack_start(tray, False, True, 0) hbox.pack_start(self.test_notebook) self.test_notebook.show() vpaned.pack2(hbox, resize=True) vpaned.show_all() tray.show() hbox.show() vbox.show_all()
class LybnizActivity(activity.Activity): def write_file(self, file_path): x, y, w, h = self.graph.drawing_area.get_allocation() pix_buffer = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, w, h) pix_buffer.get_from_drawable(self.graph.pix_map, self.graph.pix_map.get_colormap(), 0, 0, 0, 0, w, h) pix_buffer.save(file_path, "png") def parameter_entries_repopulate(self): # set text in entries for parameters self.y1_entry.set_text(y1) self.y2_entry.set_text(y2) self.y3_entry.set_text(y3) self.x_min_entry.set_text(str(self.graph.x_min)) self.x_max_entry.set_text(str(self.graph.x_max)) self.x_scale_entry.set_text(str(self.graph.x_scale)) self.y_min_entry.set_text(str(self.graph.y_min)) self.y_max_entry.set_text(str(self.graph.y_max)) self.y_scale_entry.set_text(str(self.graph.y_scale)) def zoom_in(self, widget, event=None): "Narrow the plotted section by half" center_x = (self.graph.x_min + self.graph.x_max) / 2 center_y = (self.graph.y_min + self.graph.y_max) / 2 range_x = (self.graph.x_max - self.graph.x_min) range_y = (self.graph.y_max - self.graph.y_min) self.graph.x_min = center_x - (range_x / 4) self.graph.x_max = center_x + (range_x / 4) self.graph.y_min = center_y - (range_y / 4) self.graph.y_max = center_y +(range_y / 4) self.parameter_entries_repopulate() self.graph.plot() def zoom_out(self, widget, event=None): "Double the plotted section" center_x = (self.graph.x_min + self.graph.x_max) / 2 center_y = (self.graph.y_min + self.graph.y_max) / 2 range_x = (self.graph.x_max - self.graph.x_min) range_y = (self.graph.y_max - self.graph.y_min) self.graph.x_min = center_x - (range_x) self.graph.x_max = center_x + (range_x) self.graph.y_min = center_y - (range_y) self.graph.y_max = center_y +(range_y) self.parameter_entries_repopulate() self.graph.plot() def zoom_reset(self, widget, event=None): "Set the range back to the user's input" self.graph.x_min = eval(x_min,{"__builtins__":{}},safe_dict) self.graph.y_min = eval(y_min,{"__builtins__":{}},safe_dict) self.graph.x_max = eval(x_max,{"__builtins__":{}},safe_dict) self.graph.y_max = eval(y_max,{"__builtins__":{}},safe_dict) self.x_min_entry.set_text(self.x_min) self.x_max_entry.set_text(self.x_max) self.x_scale_entry.set_text(self.x_scale) self.y_min_entry.set_text(self.y_min) self.y_max_entry.set_text(self.y_max) self.y_scale_entry.set_text(self.y_scale) self.graph.plot() def evaluate(self, widget, event=None): "Evaluate a given x for the three functions" def entry_changed(widget): for e in ((y1, dlg_win.y1_entry), (y2, dlg_win.y2_entry), (y3, dlg_win.y3_entry)): try: x = float(dlg_win.x_entry.get_text()) safe_dict['x']=x e[1].set_text(str(eval(e[0].replace("^","**"),{"__builtins__":{}},safe_dict))) except: if len(e[0]) > 0: e[1].set_text("Error: %s" % sys.exc_value) else: e[1].set_text("") def close(self): dlg_win.destroy() dlg_win = gtk.Window(gtk.WINDOW_TOPLEVEL) dlg_win.set_position(gtk.WIN_POS_CENTER) dlg_win.set_title(_("Evaluate")) dlg_win.connect("destroy", close) dlg_win.x_entry = gtk.Entry() dlg_win.x_entry.set_editable(True) dlg_win.x_entry.connect("changed", entry_changed) dlg_win.y1_entry = gtk.Entry() dlg_win.y1_entry.set_size_request(200, 24) dlg_win.y1_entry.set_sensitive(False) dlg_win.y2_entry = gtk.Entry() dlg_win.y2_entry.set_size_request(200, 24) dlg_win.y2_entry.set_sensitive(False) dlg_win.y3_entry = gtk.Entry() dlg_win.y3_entry.set_size_request(200, 24) dlg_win.y3_entry.set_sensitive(False) table = gtk.Table(2, 5) label = gtk.Label("x = ") label.set_alignment(0, .5) table.attach(label, 0, 1, 0, 1, xpadding=5, ypadding=5, xoptions=gtk.FILL) table.attach(dlg_win.x_entry, 1, 2, 0, 1) label = gtk.Label("y1 = ") label.set_alignment(0, .5) label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("blue")) table.attach(label, 0, 1, 1, 2, xpadding=5, ypadding=5, xoptions=gtk.FILL) table.attach(dlg_win.y1_entry, 1, 2, 1, 2) label = gtk.Label("y2 = ") label.set_alignment(0, .5) label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("red")) table.attach(label, 0, 1, 2, 3, xpadding=5, ypadding=5, xoptions=gtk.FILL) table.attach(dlg_win.y2_entry, 1, 2, 2, 3) label = gtk.Label("y3 = ") label.set_alignment(0, .5) label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("DarkGreen")) table.attach(label, 0, 1, 3, 4, xpadding=5, ypadding=5, xoptions=gtk.FILL) table.attach(dlg_win.y3_entry, 1, 2, 3, 4) table.set_border_width(24) dlg_win.add(table) dlg_win.show_all() def plot(self, widget, event=None): global x_max, x_min, x_scale, y_max, y_min, y_scale, y1, y2, y3 x_max = self.x_max_entry.get_text() x_min = self.x_min_entry.get_text() x_scale = self.x_scale_entry.get_text() y_max = self.y_max_entry.get_text() y_min = self.y_min_entry.get_text() y_scale = self.y_scale_entry.get_text() self.graph.x_max = eval(x_max,{"__builtins__":{}},safe_dict) self.graph.x_min = eval(x_min,{"__builtins__":{}},safe_dict) self.graph.x_scale = eval(x_scale,{"__builtins__":{}},safe_dict) self.graph.y_max = eval(y_max,{"__builtins__":{}},safe_dict) self.graph.y_min = eval(y_min,{"__builtins__":{}},safe_dict) self.graph.y_scale = eval(y_scale,{"__builtins__":{}},safe_dict) y1 = self.y1_entry.get_text() y2 = self.y2_entry.get_text() y3 = self.y3_entry.get_text() self.graph.plot() def toggle_connect(self, widget, event=None): "Toggle between a graph that connects points with lines and one that does not" global connect_points connect_points = not connect_points self.graph.plot() def scale_dec(self, widget, event=None): self.graph.scale_style = "dec" self.scale_box.hide() self.plot(None) def scale_rad(self, widget, event=None): self.graph.scale_style = "rad" self.scale_box.hide() self.plot(None) def scale_cust(self, widget, event=None): self.graph.scale_style = "cust" self.scale_box.show() self.plot(None) def __init__(self, handle): activity.Activity.__init__(self, handle) self.y1 = y1 self.y2 = y2 self.y3 = y3 self.x_max = x_max self.x_min = x_min self.x_scale = x_scale self.y_max = y_max self.y_min = y_min self.y_scale = y_scale if have_toolbox: self.toolbar_box = ToolbarBox() self.activity_button = ActivityToolbarButton(self) self.activity_button.page.share.hide() self.toolbar_box.toolbar.insert(self.activity_button, 0) self.activity_button.show() self.graph_item = ToolbarButton() self.graph_item.props.icon_name = 'graph' else: self.toolbox = activity.ActivityToolbox(self) activity_toolbar = self.toolbox.get_activity_toolbar() activity_toolbar.share.props.visible = False self.graph_toolbar = gtk.Toolbar() if have_toolbox: self.graph_item.props.page = self.graph_toolbar else: self.toolbox.add_toolbar(_('Graph'), self.graph_toolbar) self.plot_item = ToolButton('gtk-refresh') self.plot_item.props.tooltip = _("Plot") self.plot_item.connect("clicked", self.plot) self.plot_item.show() self.graph_toolbar.insert(self.plot_item, 0) self.evaluate_item = ToolButton('evaluate') self.evaluate_item.props.tooltip = _('Evaluate') self.evaluate_item.connect("clicked", self.evaluate) self.evaluate_item.show() self.graph_toolbar.insert(self.evaluate_item, -1) separator = gtk.SeparatorToolItem() separator.show() self.graph_toolbar.insert(separator, -1) self.zoom_in_item = ToolButton('zoom-in') self.zoom_in_item.props.tooltip = _('Zoom In') self.zoom_in_item.connect("clicked", self.zoom_in) self.zoom_in_item.show() self.graph_toolbar.insert(self.zoom_in_item, -1) self.zoom_out_item = ToolButton('zoom-out') self.zoom_out_item.props.tooltip = _('Zoom Out') self.zoom_out_item.connect("clicked", self.zoom_out) self.zoom_out_item.show() self.graph_toolbar.insert(self.zoom_out_item, -1) self.zoom_reset_item = ToolButton('zoom-original') self.zoom_reset_item.props.tooltip = _('Zoom Reset') self.zoom_reset_item.connect("clicked", self.zoom_reset) self.zoom_reset_item.show() self.graph_toolbar.insert(self.zoom_reset_item, -1) separator = gtk.SeparatorToolItem() separator.show() self.graph_toolbar.insert(separator, -1) self.connect_points_item = ToggleToolButton('connect-points') self.connect_points_item.set_tooltip(_("Connect Points")) self.connect_points_item.set_active(True) self.connect_points_item.connect("toggled", self.toggle_connect) self.connect_points_item.show() self.graph_toolbar.insert(self.connect_points_item, -1) separator = gtk.SeparatorToolItem() separator.show() self.graph_toolbar.insert(separator, -1) self.decimal_item = RadioToolButton() self.decimal_item.set_named_icon('decimal') self.decimal_item.set_tooltip(_("Decimal Scale Style")) self.decimal_item.connect("toggled", self.scale_dec) self.decimal_item.show() self.graph_toolbar.insert(self.decimal_item, -1) self.radians_item = RadioToolButton() self.radians_item.set_named_icon('radian') self.radians_item.set_tooltip(_("Radians Scale Style")) self.radians_item.set_group(self.decimal_item) self.radians_item.connect("toggled", self.scale_rad) self.radians_item.show() self.graph_toolbar.insert(self.radians_item, -1) self.custom_item = RadioToolButton() self.custom_item.set_named_icon('custom') self.custom_item.set_tooltip(_("Custom Scale Style")) self.custom_item.set_group(self.radians_item) self.custom_item.connect("toggled", self.scale_cust) self.custom_item.show() self.graph_toolbar.insert(self.custom_item, -1) self.graph_toolbar.show() if have_toolbox: self.graph_item.show() self.toolbar_box.toolbar.insert(self.graph_item, -1) separator = gtk.SeparatorToolItem() separator.set_draw(False) separator.set_expand(True) separator.show() self.toolbar_box.toolbar.insert(separator, -1) self.stop = StopButton(self) self.stop.show() self.toolbar_box.toolbar.insert(self.stop, -1) self.set_toolbar_box(self.toolbar_box) self.toolbar_box.show() else: self.toolbox.show() self.set_toolbox(self.toolbox) self.v_box = gtk.VBox() self.set_canvas(self.v_box) self.parameter_entries = gtk.Table(6, 3) self.y1_entry = gtk.Entry() self.y2_entry = gtk.Entry() self.y3_entry = gtk.Entry() self.x_min_entry = gtk.Entry() self.x_min_entry.set_size_request(90, 24) self.x_min_entry.set_alignment(1) self.x_max_entry = gtk.Entry() self.x_max_entry.set_size_request(90, 24) self.x_max_entry.set_alignment(1) self.x_scale_entry = gtk.Entry() self.x_scale_entry.set_size_request(90, 24) self.x_scale_entry.set_alignment(1) self.y_min_entry = gtk.Entry() self.y_min_entry.set_size_request(90, 24) self.y_min_entry.set_alignment(1) self.y_max_entry = gtk.Entry() self.y_max_entry.set_size_request(90, 24) self.y_max_entry.set_alignment(1) self.y_scale_entry = gtk.Entry() self.y_scale_entry.set_size_request(90, 24) self.y_scale_entry.set_alignment(1) self.y1_entry.set_text(self.y1) self.y2_entry.set_text(self.y2) self.y3_entry.set_text(self.y3) self.x_min_entry.set_text(self.x_min) self.x_max_entry.set_text(self.x_max) self.x_scale_entry.set_text(self.x_scale) self.y_min_entry.set_text(self.y_min) self.y_max_entry.set_text(self.y_max) self.y_scale_entry.set_text(self.y_scale) self.scale_box = gtk.HBox() label = gtk.Label("y1 = ") label.set_alignment(0, .5) label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("blue")) self.parameter_entries.attach(label, 0, 1, 0, 1, xpadding=5, ypadding=5, xoptions=gtk.FILL) self.parameter_entries.attach(self.y1_entry, 1, 2, 0, 1) label = gtk.Label(_("X min")) label.set_alignment(1, .5) self.parameter_entries.attach(label, 2, 3, 0, 1, xpadding=5, ypadding=7, xoptions=gtk.FILL) self.parameter_entries.attach(self.x_min_entry, 3, 4, 0, 1, xoptions=gtk.FILL) label = gtk.Label(_("Y min")) label.set_alignment(1, .5) self.parameter_entries.attach(label, 4, 5, 0, 1, xpadding=5, ypadding=5, xoptions=gtk.FILL) self.parameter_entries.attach(self.y_min_entry, 5, 6, 0, 1, xpadding=5, xoptions=gtk.FILL) label = gtk.Label("y2 = ") label.set_alignment(0, .5) label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("red")) self.parameter_entries.attach(label, 0, 1, 1, 2, xpadding=5, ypadding=5, xoptions=gtk.FILL) self.parameter_entries.attach(self.y2_entry, 1, 2, 1, 2) label = gtk.Label(_("X max")) label.set_alignment(1, .5) self.parameter_entries.attach(label, 2, 3, 1, 2, xpadding=5, ypadding=7, xoptions=gtk.FILL) self.parameter_entries.attach(self.x_max_entry, 3, 4, 1, 2, xoptions=gtk.FILL) label = gtk.Label(_("Y max")) label.set_alignment(1, .5) self.parameter_entries.attach(label, 4, 5, 1, 2, xpadding=5, ypadding=5, xoptions=gtk.FILL) self.parameter_entries.attach(self.y_max_entry, 5, 6, 1, 2, xpadding=5, xoptions=gtk.FILL) label = gtk.Label("y3 = ") label.set_alignment(0, .5) label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("DarkGreen")) self.parameter_entries.attach(label, 0, 1, 2, 3, xpadding=5, ypadding=5, xoptions=gtk.FILL) self.parameter_entries.attach(self.y3_entry, 1, 2, 2, 3) label = gtk.Label(_("X scale")) label.set_alignment(0, .5) self.scale_box.add(label) self.scale_box.add(self.x_scale_entry) label = gtk.Label(_("Y scale")) label.set_alignment(0, .5) self.scale_box.add(label) self.scale_box.add(self.y_scale_entry) self.parameter_entries.attach(self.scale_box, 2, 6, 2, 3, xpadding=5, xoptions=gtk.FILL) self.v_box.pack_start(self.parameter_entries, False, True, 4) self.parameter_entries.show_all() self.graph = GraphClass(self) self.v_box.pack_start(self.graph.drawing_area, True, True, 0) self.status_bar = gtk.Statusbar() self.status_bar.ContextId = self.status_bar.get_context_id("Dummy") self.status_bar.show() self.v_box.pack_end(self.status_bar, False, True, 0) self.v_box.show_all()
class ButiaToolbar(gtk.Toolbar): ''' The toolbar for specifiying the sensor: temp, distance, light or gray ''' def __init__(self, activity, channels): #Se utiliza para contralar que no se ejecute dos veces self._butia_context_id = None gtk.Toolbar.__init__(self) self.activity = activity self._channels = channels self.mode = 'butia' # Set up Sensores Button self.time = RadioToolButton(group=None) # Mantiene la lista de botones (de sensores) # agregados a la ButiaToolbar self.lista_sensores_button = [] self.we_are_logging = False self._log_this_sample = False self._logging_timer = None self._logging_counter = 0 self._image_counter = 0 self._logging_interval = 0 self._channels_logged = [] self._busy = False self._take_screenshot = True # BUTIA Se detectan sensores log.debug('se agrega el boton refrescar') self.refrescar_button = RadioToolButton(group=None) self.refrescar_button.set_named_icon('recargar') self.refrescar_button.connect('clicked', self.update_buttons) self.insert(self.refrescar_button, -1) separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self.detect_sensors() self.load_buttons() separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self._log_interval_combo = ComboBox() self.interval = [ _('1/10 second'), _('1 second'), _('30 seconds'), _('5 minutes'), _('30 minutes') ] if hasattr(self._log_interval_combo, 'set_tooltip_text'): self._log_interval_combo.set_tooltip_text(_('Sampling interval')) self._interval_changed_id = self._log_interval_combo.connect( 'changed', self.log_interval_cb) for i, s in enumerate(self.interval): self._log_interval_combo.append_item(i, s, None) if s == _('1 second'): self._log_interval_combo.set_active(i) self._log_interval_tool = ToolComboBox(self._log_interval_combo) self.insert(self._log_interval_tool, -1) self.logging_interval_status = '1 second' # Set up Logging/Stop Logging Button self._record = ToolButton('media-record') self.insert(self._record, -1) self._record.set_tooltip(_('Start Recording')) self._record.connect('clicked', self.record_control_cb) self.show_all() # BUTIA Busca modulos conectados y pregunta si son sensores def detect_sensors(self): self.robot = butiaAPI.robot() log.debug('listando modulos detectados:') modules = self.robot.get_modules_list() self.sensores = [] log.debug(modules) for i in range(len(modules)): if self.is_sensor(modules[i]): log.debug(modules[i] + ' es sensor!') self.sensores.append(modules[i]) else: log.debug(modules[i] + ' no es sensor!') self.sensores.sort() log.debug('sensores: ') log.debug(self.sensores) # BUTIA determina si el modulo que le pasan es sensor! ! def is_sensor(self, module): is_sensor = 0 descripcion = 'A' #log.debug('DESCRIBIENDO: '+ module) descripcion = self.robot.doCommand('DESCRIBE ' + module) if descripcion == -1: return 0 #log.debug(descripcion) is_sensor = descripcion.count( 'returns={[1]') and module != 'display' and module != 'butia' return is_sensor #BUTIA Cargo los botones para cada sensor detectado def load_buttons(self): self.lista_sensores_button = [] for i in range(len(self.sensores)): self.sensor = self.sensores[i] log.debug('agregando boton para : ' + self.sensor) #radio_tool_button = 0 radio_tool_button = RadioToolButton(group=self.time) icono = self.sensor.strip('0123456789:') radio_tool_button.set_named_icon(icono) radio_tool_button.set_tooltip(_(self.sensor)) if self.sensor.count('temp'): #determino el numero de sensor y lo paso por parametro. #log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) ) radio_tool_button.connect('clicked', self.click_temp_button, self.get_sensor_number(self.sensor)) elif self.sensor.count('dist'): #log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) ) radio_tool_button.connect('clicked', self.click_dist_button, self.get_sensor_number(self.sensor)) elif self.sensor.count('grey'): #log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) ) radio_tool_button.connect('clicked', self.click_grises_button, self.get_sensor_number(self.sensor)) elif self.sensor.count('light'): #log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) ) radio_tool_button.connect('clicked', self.click_luz_button, self.get_sensor_number(self.sensor)) self.insert(radio_tool_button, 2) self.lista_sensores_button.append(radio_tool_button) def update_buttons(self, button=None): for s in self.lista_sensores_button: self.remove(s) self.detect_sensors() self.load_buttons() self.show_all() def get_sensor_number(self, sensor): number = 0 sensor_trunked = sensor.strip('0123456789') number = sensor.strip(sensor_trunked) log.debug('sensor number :' + sensor.strip(sensor)) return number # BUTIA metodos para leen sensores def read_temp_from_bobot_server(self, num=0): #log.debug('**********Sensando temperature' + str(num)+ '***********') value = 0 value = self.robot.callModule('temp:' + str(num), 'getValue') #log.debug('temperature : ' + value) return value def read_dist_from_bobot_server(self, num=0): #log.debug('**********Sensando distance'+ str(num) + '******************') value = 0 #value = self.robot.getDistance(num) value = self.robot.callModule('distanc:' + str(num), 'getValue') #log.debug('distance = ' + str(value)) return value def read_grises_from_bobot_server(self, num=0): #log.debug('**********Sensando grises'+ str(num) + '******************') value = '0' value = self.robot.callModule('grey:' + str(num), 'getValue') #log.debug('grey = ' + str(value)) return value def read_luz_from_bobot_server(self, num=0): #log.debug('**********Sensando luz '+ str(num) + '******************') value = '0' value = self.robot.callModule('ligth:' + str(num), 'getValue') #log.debug('grey = ' + str(value)) return value def read_sensor_from_bobot_server(self, num): log.debug('**********Read Sensor ***********') return 0 def click_button(self, button=None): log.debug('********** clicka botton ***********') self.set_butia_context() return False def click_temp_button(self, button=None, num='0'): log.debug('********** clickea botton temp ***********') self.mode = 'temperatura' self.read_sensor_from_bobot_server = self.read_temp_from_bobot_server self.set_butia_context(num) return False def click_dist_button(self, button=None, num='0'): log.debug('********** clickea botton dist ***********') self.mode = 'distancia' self.read_sensor_from_bobot_server = self.read_dist_from_bobot_server self.activity.limpiar_canales() self.set_butia_context(num) return False def click_grises_button(self, button=None, num='0'): log.debug('********** clickea botton grises ***********') self.mode = 'grises' self.read_sensor_from_bobot_server = self.read_grises_from_bobot_server self.activity.limpiar_canales() self.set_butia_context(num) return False def click_luz_button(self, button=None, num='0'): log.debug('********** clickea botton luz ***********') self.mode = 'luz' self.read_sensor_from_bobot_server = self.read_luz_from_bobot_server self.activity.limpiar_canales() self.set_butia_context(num) return False def set_butia_context(self, num='0'): self.activity.audiograb.stop_grabbing() if self._butia_context_id: gobject.source_remove(self._butia_context_id) self._butia_context_id =\ gobject.timeout_add(50,self.butia_context_on,num) def butia_context_on(self, num='0'): bufChannelTmp = [] #Si esta el boton de pause activada no se agregar el nuevo valor if self.activity.audiograb.get_freeze_the_display(): bufChannelTmp.append(self.read_sensor_from_bobot_server(num)) for i in range(self.activity.audiograb.channels): self.activity.wave.new_buffer(bufChannelTmp, i) if self.we_are_logging: self.logging_to_file(bufChannelTmp, i) if self.activity.CONTEXT == 'butia': return True else: return False def logging_to_file(self, data_buffer, channel): if self.we_are_logging: if self._logging_counter == MAX_LOG_ENTRIES: self._logging_counter = 0 self.we_are_logging = False self.activity.data_logger.stop_session() else: if self._logging_interval == 0: self._emit_for_logging(data_buffer, channel=channel) self._log_this_sample = False self.we_are_logging = False self.activity.data_logger.stop_session() elif self._log_this_sample: # Sample channels in order if self.activity.audiograb._channels_logged.index( False) == channel: self.activity.audiograb._channels_logged[ channel] = True self._emit_for_logging(data_buffer, channel=channel) # Have we logged every channel? if self.activity.audiograb._channels_logged.count( True) == self.activity.audiograb.channels: self._log_this_sample = False for i in range(self.activity.audiograb.channels): self.activity.audiograb._channels_logged[ i] = False self._logging_counter += 1 def _emit_for_logging(self, data_buffer, channel=0): '''Sends the data for logging''' if not self._busy: self._busy = True if self._take_screenshot: if self.activity.data_logger.take_screenshot( self._image_counter): self._image_counter += 1 else: log.debug('failed to take screenshot %d' % (self._logging_counter)) self._busy = False return value_string = data_buffer[0] if self.activity.audiograb.channels > 1: self.activity.data_logger.write_value( value_string, channel=channel, sample=self._logging_counter) else: self.activity.data_logger.write_value( value_string, sample=self._logging_counter) self._busy = False else: log.debug('skipping sample %d.%d' % (self._logging_counter, channel)) def _sample_now(self): ''' Log the current sample now. This method is called from the _logging_timer object when the interval expires. ''' self._log_this_sample = True self._make_timer() def _make_timer(self): ''' Create the next timer that will trigger data logging. ''' self._logging_timer = Timer(self._logging_interval, self._sample_now) self._logging_timer.start() def record_control_cb(self, button=None): ''' Depending upon the selected interval, does either a logging session, or just logs the current buffer. ''' if self.we_are_logging: self.set_logging_params(start_stop=False) self._record.set_icon('media-record') self._record.show() self._record.set_tooltip(_('Start Recording')) else: Xscale = 0.0 Yscale = 0.0 interval = self.interval_convert() username = self.activity.nick if self.activity.wave.get_fft_mode(): self.activity.data_logger.start_new_session( username, Xscale, Yscale, _(self.logging_interval_status), channels=self._channels, mode='frequency') else: self.activity.data_logger.start_new_session( username, Xscale, Yscale, _(self.logging_interval_status), channels=self._channels, mode=self.mode) self.set_logging_params(start_stop=True, interval=interval, screenshot=False) self._record.set_icon('record-stop') self._record.show() self._record.set_tooltip(_('Stop Recording')) self.activity.new_recording = True def set_logging_params(self, start_stop=False, interval=0, screenshot=True): ''' Configures for logging of data: starts or stops a session; sets the logging interval; and flags if screenshot is taken. ''' self.we_are_logging = start_stop self._logging_interval = interval if not start_stop: if self._logging_timer: self._logging_timer.cancel() self._logging_timer = None self._log_this_sample = False self._logging_counter = 0 elif interval != 0: self._make_timer() self._take_screenshot = screenshot self._busy = False def interval_convert(self): ''' Converts interval string to an integer that denotes the number of times the audiograb buffer must be called before a value is written. When set to 0, the whole of current buffer will be written. ''' interval_dictionary = { '1/10 second': 0.1, '1 second': 1, '30 seconds': 30, '5 minutes': 300, '30 minutes': 1800 } try: return interval_dictionary[self.logging_interval_status] except ValueError: logging.error('logging interval status = %s' %\ (str(self.logging_interval_status))) return 0 def log_interval_cb(self, combobox): ''' Callback from the Logging Interval Combo box: sets status ''' if self._log_interval_combo.get_active() != -1: intervals = [ '1/10 second', '1 second', '30 seconds', '5 minutes', '30 minutes' ] self.logging_interval_status = \ intervals[self._log_interval_combo.get_active()] def take_screenshot(self): ''' Capture the current screen to the Journal ''' log.debug('taking a screenshot %d' % (self._logging_counter)) self.set_logging_params(start_stop=True, interval=0, screenshot=True)
class SensorToolbar(gtk.Toolbar): ''' The toolbar for specifiying the sensor: sound, resitance, or voltage ''' LOWER = 0.0 UPPER = 1.0 STR_DC_R = \ _("Resistive sensor (connect sensor to pink 'Mic In' on left side \ of XO)" ) + ' ' STR_DC_V = \ _("Voltage sensor (connect sensor to pink 'Mic In' on left side \ of XO)" ) + ' ' STR_AC = _('Sound') + ' ' STR_RESISTANCE = _('Resistance') + ' (' + _('Ohms') + ') ' STR_VOLTAGE = _('Voltage') + ' (' + _('Volts') + ') ' STR_TIME = _('Time Base') + ' ' STR_FREQUENCY = _('Frequency Base') + ' ' STR_INVERT = ' ' + _('Invert') + ' ' STR_XAXIS_TEXT = _('X Axis Scale: 1 division = %(division)s %(unit)s') # TRANSLATORS: This is milli seconds. MS = _('ms') # TRANSLATORS: This is Hertz, so 1/second. HZ = _('Hz') def __init__(self, activity, channels): ''' By default, start with resistance mode ''' gtk.Toolbar.__init__(self) self.activity = activity self._channels = channels self._lock_radio_buttons = False self._radio_button_pushed = False self.values = [] for i in range(self._channels): self.values.append('') self.string_for_textbox = '' self.gain = 1.0 self.y_mag = 3.0 self.capture_gain = CAPTURE_GAIN self.mic_boost = MIC_BOOST self.mode = 'sound' # Set up Time-domain Button self.time = RadioToolButton(group=None) self.time.set_named_icon('media-audio') self.insert(self.time, -1) self.time.set_tooltip(_('Sound')) self.time.connect('clicked', self.analog_resistance_voltage_mode_cb, 'sound') # Set up Resistance Button self.resistance = RadioToolButton(group=self.time) self.resistance.set_named_icon('resistance') if _is_xo(self.activity.hw): self.insert(self.resistance, -1) self.resistance.show() self.resistance.set_tooltip(_('Resistance Sensor')) self.resistance.connect('clicked', self.analog_resistance_voltage_mode_cb, 'resistance') # Set up Voltage Button self.voltage = RadioToolButton(group=self.time) self.voltage.set_named_icon('voltage') if _is_xo(self.activity.hw): self.insert(self.voltage, -1) self.voltage.set_tooltip(_('Voltage Sensor')) self.voltage.connect('clicked', self.analog_resistance_voltage_mode_cb, 'voltage') separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self._log_value = LOG_TIMER_VALUES[1] self.log_label = gtk.Label(self._log_to_string(self._log_value)) toolitem = gtk.ToolItem() toolitem.add(self.log_label) self.insert(toolitem, -1) self._log_button = ToolButton('timer-10') self._log_button.set_tooltip(_('Select logging interval')) self._log_button.connect('clicked', self._log_selection_cb) self.insert(self._log_button, -1) self._setup_log_palette() # Set up Logging/Stop Logging Button self._record = ToolButton('media-record') self.insert(self._record, -1) self._record.set_tooltip(_('Start logging')) self._record.connect('clicked', self.record_control_cb) separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) toolitem = gtk.ToolItem() self.trigger_label = gtk.Label(_('Trigger')) toolitem.add(self.trigger_label) self.insert(toolitem, -1) # Set up Trigger Combo box self.trigger_none = RadioToolButton() self.trigger_none.set_named_icon('trigger-none') self.insert(self.trigger_none, -1) self.trigger_none.set_tooltip(_('None')) self.trigger_none.connect('clicked', self.update_trigger_control_cb, self.activity.wave.TRIGGER_NONE) self.trigger_rise = RadioToolButton(group=self.trigger_none) self.trigger_rise.set_named_icon('trigger-rise') self.insert(self.trigger_rise, -1) self.trigger_rise.set_tooltip(_('Rising Edge')) self.trigger_rise.connect('clicked', self.update_trigger_control_cb, self.activity.wave.TRIGGER_POS) self.trigger_fall = RadioToolButton(group=self.trigger_none) self.trigger_fall.set_named_icon('trigger-fall') self.insert(self.trigger_fall, -1) self.trigger_fall.set_tooltip(_('Falling Edge')) self.trigger_fall.connect('clicked', self.update_trigger_control_cb, self.activity.wave.TRIGGER_NEG) self.show_all() def get_log(self): return self._log_value def get_log_idx(self): if self._log_value in LOG_TIMER_VALUES: return LOG_TIMER_VALUES.index(self._log_value) else: return LOG_TIMER_VALUES[0] def set_log_idx(self, idx): self._log_value = LOG_TIMER_VALUES[idx] self.log_label.set_text(self._log_to_string(self._log_value)) if hasattr(self, '_log_button'): self._log_button.set_icon('timer-%d' % (self._log_value)) def _log_selection_cb(self, widget): if self._log_palette: if not self._log_palette.is_up(): self._log_palette.popup(immediate=True, state=self._log_palette.SECONDARY) else: self._log_palette.popdown(immediate=True) return def _log_to_seconds(self, tenth_seconds): return tenth_seconds / 10. def _log_to_string(self, tenth_seconds): if tenth_seconds in LOG_TIMER_LABELS: return LOG_TIMER_LABELS[tenth_seconds] else: return _('1 second') def _setup_log_palette(self): self._log_palette = self._log_button.get_palette() for tenth_seconds in LOG_TIMER_VALUES: text = self._log_to_string(tenth_seconds) menu_item = MenuItem(icon_name='timer-%d' % (tenth_seconds), text_label=self._log_to_string(tenth_seconds)) menu_item.connect('activate', self._log_selected_cb, tenth_seconds) self._log_palette.menu.append(menu_item) menu_item.show() def _log_selected_cb(self, button, seconds): self.set_log_idx(LOG_TIMER_VALUES.index(seconds)) def add_frequency_slider(self, toolbox): ''' Either on the Sound toolbar or the Main toolbar ''' self._freq_stepper_up = ToolButton('freq-high') self._freq_stepper_up.set_tooltip(_('Zoom out')) self._freq_stepper_up.connect('clicked', self._freq_stepper_up_cb) self._freq_stepper_up.show() self.activity.adjustmentf = gtk.Adjustment(0.5, self.LOWER, self.UPPER, 0.01, 0.1, 0) self.activity.adjustmentf.connect('value_changed', self.cb_page_sizef) self._freq_range = gtk.HScale(self.activity.adjustmentf) self._freq_range.set_inverted(True) self._freq_range.set_draw_value(False) self._freq_range.set_update_policy(gtk.UPDATE_CONTINUOUS) self._freq_range.set_size_request(120, 15) self._freq_range.show() self._freq_stepper_down = ToolButton('freq-low') self._freq_stepper_down.set_tooltip(_('Zoom in')) self._freq_stepper_down.connect('clicked', self._freq_stepper_down_cb) self._freq_stepper_down.show() self._freq_range_tool = gtk.ToolItem() self._freq_range_tool.add(self._freq_range) self._freq_range_tool.show() toolbox.add(self._freq_stepper_up) toolbox.add(self._freq_range_tool) toolbox.add(self._freq_stepper_down) return def update_trigger_control_cb(self, button, value): if button is None: value = self.activity.wave.TRIGGER_NONE if self.activity.wave.get_fft_mode(): self.trigger_none.set_active(True) else: self.activity.wave.set_trigger(value) def analog_resistance_voltage_mode_cb(self, button=None, mode_to_set='sound'): ''' Callback for Analog/Resistance/Voltage Buttons ''' if self._lock_radio_buttons: logging.debug('mode selector locked') self._radio_button_pushed = True return if self.mode == mode_to_set: logging.debug('mode already set to %s' % mode_to_set) return self._lock_radio_buttons = True if self.activity.CONTEXT == 'sound': self.sound_context_off() else: self.sensor_context_off() # Force time domain when switching modes if self.activity.wave.get_fft_mode(): self.activity.timefreq_control() # Turn off logging when switching modes if self.activity.audiograb.we_are_logging: self.record_control_cb() self.set_mode(mode_to_set) if mode_to_set == 'sound': self.set_sound_context() elif mode_to_set == 'resistance': self.set_sensor_context() elif mode_to_set == 'voltage': self.set_sensor_context() self.update_string_for_textbox() return False def unlock_radio_buttons(self): ''' Enable radio button selection ''' logging.debug('unlocking radio buttons') if self._radio_button_pushed: if self.mode == 'sound': self.time.set_active(True) elif self.mode == 'resistance': self.resistance.set_active(True) elif self.mode == 'voltage': self.voltage.set_active(True) self._lock_radio_buttons = False self._radio_button_pushed = False def set_mode(self, mode='sound'): ''' Set the mixer settings to match the current mode. ''' self.mode = mode self.activity.audiograb.set_sensor_type(self.mode) for i in range(self._channels): self.values[i] = 0.0 return def get_mode(self): ''' Get the mixer settings. ''' return self.mode def _freq_stepper_up_cb(self, button=None): ''' Moves the horizontal zoom slider to the left one notch, where one notch is 1/100 of the total range. This correspond to zooming out as a larger number of Hertz or milliseconds will be represented by the same space on the screen. ''' new_value = self._freq_range.get_value() +\ (self.UPPER - self.LOWER) / 100.0 if new_value <= self.UPPER: self._freq_range.set_value(new_value) else: self._freq_range.set_value(self.UPPER) def _freq_stepper_down_cb(self, button=None): ''' Moves the horizontal zoom slider to the right one notch, where one notch is 1/100 of the total range. This corresponds to zooming in. ''' new_value = self._freq_range.get_value() -\ (self.UPPER - self.LOWER) / 100.0 if new_value >= self.LOWER: self._freq_range.set_value(new_value) else: self._freq_range.set_value(self.LOWER) def cb_page_sizef(self, button=None): ''' Callback to scale the frequency range (zoom in and out) ''' if self._update_page_size_id: gobject.source_remove(self._update_page_size_id) self._update_page_size_id =\ gobject.timeout_add(250, self.update_page_size) return True def update_page_size(self): ''' Set up the scaling of the display. ''' self._update_page_size_id = None new_value = round(self.activity.adjustmentf.value * 100.0) / 100.0 if self.activity.adjustmentf.value != new_value: self.activity.adjustmentf.value = new_value return False time_div = 0.001 * max(self.activity.adjustmentf.value, 0.05) freq_div = 1000 * max(self.activity.adjustmentf.value, 0.01) self.activity.wave.set_div(time_div, freq_div) self.update_string_for_textbox() return False def set_sound_context(self): ''' Called when analog sensing is selected ''' self.set_show_hide_windows(mode='sound') gobject.timeout_add(500, self.sound_context_on) self.activity.CONTEXT = 'sound' def set_sensor_context(self): ''' Called when digital sensing is selected ''' self.set_show_hide_windows(mode='sensor') gobject.timeout_add(500, self.sensor_context_on) self.activity.CONTEXT = 'sensor' def set_show_hide_windows(self, mode='sound'): ''' Shows the appropriate window identified by the mode ''' self.activity.wave.set_context_on() for i in range(self._channels): self.activity.side_toolbars[i].set_show_hide(True, mode) def sensor_context_off(self): ''' Called when a DC sensor is no longer selected ''' # self.activity.audiograb.pause_grabbing() self.activity.audiograb.stop_grabbing() def sensor_context_on(self): ''' Called when a DC sensor is selected ''' self.update_string_for_textbox() self.activity.wave.set_trigger(self.activity.wave.TRIGGER_NONE) # self.activity.audiograb.resume_grabbing() self.activity.audiograb.start_grabbing() return False def sound_context_off(self): ''' Called when an analog sensor is no longer selected ''' self.gain, self.y_mag = self.activity.wave.get_mag_params() self.capture_gain = self.activity.audiograb.get_capture_gain() self.mic_boost = self.activity.audiograb.get_mic_boost() self.activity.audiograb.stop_grabbing() def sound_context_on(self): ''' Called when an analog sensor is selected ''' self.activity.wave.set_mag_params(self.gain, self.y_mag) self.update_string_for_textbox() self.update_trigger_control_cb(None, self.activity.wave.TRIGGER_NONE) self.activity.audiograb.start_grabbing() return False def set_sample_value(self, value='', channel=0): ''' Write a sample value to the textbox. ''' gtk.threads_enter() self.values[channel] = value self.update_string_for_textbox() gtk.threads_leave() return def record_control_cb(self, button=None): ''' Depending upon the selected interval, does either a logging session, or just logs the current buffer. ''' if self.activity.audiograb.we_are_logging: self.activity.audiograb.set_logging_params(start_stop=False) self._record.set_icon('media-record') self._record.show() self._record.set_tooltip(_('Start Recording')) else: Xscale = (1.00 / self.activity.audiograb.get_sampling_rate()) Yscale = 0.0 interval = self._log_value / 10. # self.interval_convert() username = self.activity.nick if self.activity.wave.get_fft_mode(): self.activity.data_logger.start_new_session( username, Xscale, Yscale, self._log_to_string(self._log_value), channels=self._channels, mode='frequency') else: self.activity.data_logger.start_new_session( username, Xscale, Yscale, self._log_to_string(self._log_value), channels=self._channels, mode=self.mode) self.activity.audiograb.set_logging_params(start_stop=True, interval=interval, screenshot=False) self._record.set_icon('record-stop') self._record.show() self._record.set_tooltip(_('Stop Recording')) self.activity.new_recording = True def update_string_for_textbox(self): ''' Update the status field at the bottom of the canvas. ''' if self.mode == 'resistance': string_for_textbox = (self.STR_DC_R + '\n') string_for_textbox += self.STR_RESISTANCE elif self.mode == 'voltage': string_for_textbox = (self.STR_DC_V + '\n') string_for_textbox += self.STR_VOLTAGE else: string_for_textbox = (self.STR_AC + '\t') if self.activity.wave.get_fft_mode(): scalex = self.STR_XAXIS_TEXT % { 'unit': self.HZ, 'division': self.activity.wave.freq_div } string_for_textbox += self.STR_FREQUENCY string_for_textbox += ('\n' + scalex) elif self.mode == 'sound': scalex = self.STR_XAXIS_TEXT % { 'unit': self.MS, 'division': self.activity.wave.time_div * 1000 } string_for_textbox += self.STR_TIME string_for_textbox += ('\n' + scalex) else: for i in range(self._channels): string_for_textbox += '\t(%s)' % (self.values[i]) invert = False for i in range(self._channels): if self.activity.wave.get_invert_state(channel=i): invert = True if invert: string_for_textbox += self.STR_INVERT self.activity.text_box.set_label(string_for_textbox)
class LegoToolbar(gtk.Toolbar): ''' The toolbar for specifiying the sensor: temp, distance, light or gray ''' def __init__(self, activity, channels): #Its used to avoid it from running twice self._lego_context_id = None gtk.Toolbar.__init__(self) self.activity = activity self._channels = channels self.mode = 'lego' # Set up Sensores Button self.time = RadioToolButton(group=None) # Keeps the button list (sensors) # added to the LegoToolbar self.lista_sensores_button = [] self.we_are_logging = False self._log_this_sample = False self._logging_timer = None self._logging_counter = 0 self._image_counter = 0 self._logging_interval = 0 self._port_status = 1 self._channels_logged = [] self._busy = False self._take_screenshot = True self.refrescar_button = RadioToolButton(group=None) self.refrescar_button.set_named_icon('recargar') self.insert(self.refrescar_button, -1) separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self.load_buttons() separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self._port = PORT_VALUES[0] self.port_label = gtk.Label(self._port_to_string(self._port)) toolitem = gtk.ToolItem() toolitem.add(self.port_label) self.insert(toolitem, -1) self._port_button = ToolButton('LEGO-tools') self._port_button.set_tooltip(_('Select Port')) self._port_button.connect('clicked', self._port_selection_cb) self.insert(self._port_button, -1) self._setup_port_palette() separator = gtk.SeparatorToolItem() separator.props.draw = True self.insert(separator, -1) self._log_value = LOG_TIMER_VALUES[1] self.log_label = gtk.Label(self._log_to_string(self._log_value)) toolitem = gtk.ToolItem() toolitem.add(self.log_label) self.insert(toolitem, -1) self._log_button = ToolButton('timer-10') self._log_button.set_tooltip(_('Select logging interval')) self._log_button.connect('clicked', self._log_selection_cb) self.insert(self._log_button, -1) self._setup_log_palette() # Set up Logging/Stop Logging Button self._record = ToolButton('media-record') self.insert(self._record, -1) self._record.set_tooltip(_('Start Recording')) self._record.connect('clicked', self.record_control_cb) self.show_all() def get_log(self): return self._log_value def get_log_idx(self): if self._log_value in LOG_TIMER_VALUES: return LOG_TIMER_VALUES.index(self._log_value) else: return LOG_TIMER_VALUES[0] def set_log_idx(self, idx): self._log_value = LOG_TIMER_VALUES[idx] self.log_label.set_text(self._log_to_string(self._log_value)) if hasattr(self, '_log_button'): self._log_button.set_icon('timer-%d' % (self._log_value)) def _log_selection_cb(self, widget): if self._log_palette: if not self._log_palette.is_up(): self._log_palette.popup(immediate=True, state=self._log_palette.SECONDARY) else: self._log_palette.popdown(immediate=True) return def _log_to_seconds(self, tenth_seconds): return tenth_seconds / 10. def _log_to_string(self, tenth_seconds): if tenth_seconds in LOG_TIMER_LABELS: return LOG_TIMER_LABELS[tenth_seconds] else: return _('1 second') def _setup_log_palette(self): self._log_palette = self._log_button.get_palette() for tenth_seconds in LOG_TIMER_VALUES: text = self._log_to_string(tenth_seconds) menu_item = MenuItem(icon_name='timer-%d' % (tenth_seconds), text_label=self._log_to_string(tenth_seconds)) menu_item.connect('activate', self._log_selected_cb, tenth_seconds) self._log_palette.menu.append(menu_item) menu_item.show() def _log_selected_cb(self, button, seconds): self.set_log_idx(LOG_TIMER_VALUES.index(seconds)) def get_port(self): return self._port_value def get_port_idx(self): if self._port_value in PORT_VALUES: return PORT_VALUES.index(self._port_value) else: return PORT_VALUES[0] def set_port_idx(self, idx): self._port_value = PORT_VALUES[idx] self.port_label.set_text(self._port_to_string(self._port_value)) if hasattr(self, '_port_button'): self._port_button.set_icon('LEGO-tools') def _port_selection_cb(self, widget): if self._port_palette: if not self._port_palette.is_up(): self._port_palette.popup(immediate=True, state=self._port_palette.SECONDARY) else: self._port_palette.popdown(immediate=True) return def _port_to_string(self, tenth_seconds): if tenth_seconds in PORT_LABELS: return PORT_LABELS[tenth_seconds] else: return _('1 second') def _setup_port_palette(self): self._port_palette = self._port_button.get_palette() for tenth_seconds in PORT_VALUES: text = self._port_to_string(tenth_seconds) menu_item = MenuItem(icon_name='LEGO-tools', text_label=self._port_to_string(tenth_seconds)) menu_item.connect('activate', self._port_selected_cb, tenth_seconds) self._port_palette.menu.append(menu_item) menu_item.show() def _port_selected_cb(self, button, seconds): self.set_port_idx(PORT_VALUES.index(seconds)) #LEGO set up the sensor buttons def load_buttons(self): self.sensores = [_('Light Sensor'), _('Distance Sensor'), _('Grey Sensor'), _('Button Sensor'), _('Sound Sensor')] self.lista_sensores_button = [] for i in range(len(self.sensores)): self.sensor = self.sensores[i] radio_tool_button = RadioToolButton(group=self.time) icono = self.sensor.strip('0123456789:') radio_tool_button.set_named_icon(icono) radio_tool_button.set_tooltip(_(self.sensor)) if self.sensor.count(_('Sound Sensor')): radio_tool_button.connect('clicked',self.click_sound_button) if self.sensor.count(_('Distance Sensor')): radio_tool_button.connect('clicked',self.click_dist_button) elif self.sensor.count(_('Grey Sensor')): radio_tool_button.connect('clicked',self.click_grises_button) elif self.sensor.count(_('Button Sensor')): radio_tool_button.connect('clicked',self.click_button) log.debug(self.sensores) elif self.sensor.count(_('Light sensor')): radio_tool_button.connect('clicked',self.click_luz_button) self.insert(radio_tool_button, 2) self.lista_sensores_button.append(radio_tool_button) def get_sensor_number(self): log.debug('GETING SENSOR NUMBER') log.debug(str(self._port_status)) return self._port_status # LEGO reading sensor functions def read_sound_from_bobot_server(self): return nxt.getSound(self.get_port()) def read_dist_from_bobot_server(self): return nxt.getDistance(self.get_port()) def read_boton_from_bobot_server(self): return nxt.getButton(self.get_port()) def read_grises_from_bobot_server(self): return nxt.getGray(self.get_port()) def read_luz_from_bobot_server(self): return nxt.getLight(self.get_port()) def read_sensor_from_bobot_server(self): return 0 def click_button(self,button=None): self.set_lego_context() return False def click_sound_button(self, button=None): self.mode = 'temperatura' self.read_sensor_from_bobot_server = self.read_sound_from_bobot_server self.set_lego_context() return False def click_dist_button(self, button=None): self.mode = 'distancia' self.read_sensor_from_bobot_server = self.read_dist_from_bobot_server self.activity.limpiar_canales() self.set_lego_context() return False def click_boton_button(self, button=None): self.mode = 'boton' self.read_sensor_from_bobot_server = self.read_boton_from_bobot_server self.activity.limpiar_canales() self.set_lego_context() return False def click_grises_button(self, button=None): self.mode = 'grises' self.read_sensor_from_bobot_server = self.read_grises_from_bobot_server self.activity.limpiar_canales() self.set_lego_context() return False def click_luz_button(self, button=None): self.mode = 'luz' self.read_sensor_from_bobot_server = self.read_luz_from_bobot_server self.activity.limpiar_canales() self.set_lego_context() return False def set_lego_context(self): self.activity.audiograb.stop_grabbing() if self._lego_context_id: gobject.source_remove(self._lego_context_id) self._lego_context_id =\ gobject.timeout_add(50,self.lego_context_on) def lego_context_on(self): bufChannelTmp = [] #If pause button is active, do not add the value if self.activity.audiograb.get_freeze_the_display(): bufChannelTmp.append(self.read_sensor_from_bobot_server()) for i in range(self.activity.audiograb.channels): self.activity.wave.new_buffer(bufChannelTmp,i) if self.we_are_logging: self.logging_to_file(bufChannelTmp,i) if self.activity.CONTEXT == 'lego': return True else: return False def logging_to_file(self, data_buffer, channel): if self.we_are_logging: if self._logging_counter == MAX_LOG_ENTRIES: self._logging_counter = 0 self.we_are_logging = False self.activity.data_logger.stop_session() else: if self._logging_interval == 0: self._emit_for_logging(data_buffer, channel=channel) self._log_this_sample = False self.we_are_logging = False self.activity.data_logger.stop_session() elif self._log_this_sample: # Sample channels in order if self.activity.audiograb._channels_logged.index(False) ==\ channel: self.activity.audiograb._channels_logged[channel] =\ True self._emit_for_logging(data_buffer, channel=channel) # Have we logged every channel? if self.activity.audiograb._channels_logged.count(True)\ == self.activity.audiograb.channels: self._log_this_sample = False for i in range(self.activity.audiograb.channels): self.activity.audiograb._channels_logged[i] =\ False self._logging_counter += 1 def _emit_for_logging(self, data_buffer, channel=0): '''Sends the data for logging''' if not self._busy: self._busy = True if self._take_screenshot: if self.activity.data_logger.take_screenshot( self._image_counter): self._image_counter += 1 else: log.debug('failed to take screenshot %d' % ( self._logging_counter)) self._busy = False return value_string = data_buffer[0] def _sample_now(self): ''' Log the current sample now. This method is called from the _logging_timer object when the interval expires. ''' self._log_this_sample = True self._make_timer() def _make_timer(self): ''' Create the next timer that will trigger data logging. ''' self._logging_timer = Timer(self._logging_interval, self._sample_now) self._logging_timer.start() def record_control_cb(self, button=None): ''' Depending upon the selected interval, does either a logging session, or just logs the current buffer. ''' if self.we_are_logging: self.activity.audiograb.set_logging_params(start_stop=False) self._record.set_icon('media-record') self._record.show() self._record.set_tooltip(_('Start Recording')) else: Xscale = (1.00 / self.activity.audiograb.get_sampling_rate()) Yscale = 0.0 interval = self._log_value / 10. # self.interval_convert() username = self.activity.nick if self.activity.wave.get_fft_mode(): self.activity.data_logger.start_new_session( username, Xscale, Yscale, self._log_to_string(self._log_value), channels=self._channels, mode='frequency') else: self.activity.data_logger.start_new_session( username, Xscale, Yscale, self._log_to_string(self._log_value), channels=self._channels, mode=self.mode) self.set_logging_params( start_stop=True, interval=interval, screenshot=False) self._record.set_icon('record-stop') self._record.show() self._record.set_tooltip(_('Stop Recording')) self.activity.new_recording = True def set_logging_params(self, start_stop=False, interval=0, screenshot=True): ''' Configures for logging of data: starts or stops a session; sets the logging interval; and flags if screenshot is taken. ''' self.we_are_logging = start_stop self._logging_interval = interval if not start_stop: if self._logging_timer: self._logging_timer.cancel() self._logging_timer = None self._log_this_sample = False self._logging_counter = 0 elif interval != 0: self._make_timer() self._take_screenshot = screenshot self._busy = False def interval_convert(self): ''' Converts interval string to an integer that denotes the number of times the audiograb buffer must be called before a value is written. When set to 0, the whole of current buffer will be written. ''' interval_dictionary = {'1/10 second': 0.1, '1 second': 1, '30 seconds': 30, '5 minutes': 300, '30 minutes': 1800} try: return interval_dictionary[self.logging_interval_status] except ValueError: logging.error('logging interval status = %s' %\ (str(self.logging_interval_status))) return 0 def take_screenshot(self): ''' Capture the current screen to the Journal ''' log.debug('taking a screenshot %d' % (self._logging_counter)) self.set_logging_params(start_stop=True, interval=0, screenshot=True)