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._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 __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)
