diff --git a/dstat_interface/interface/adc_pot.py b/dstat_interface/interface/adc_pot.py
old mode 100644
new mode 100755
index 6fdbd598d6b09238110150b51cff247779738241..751c9ca83823de233e48f2aa190d905eef6e71b5
--- a/dstat_interface/interface/adc_pot.py
+++ b/dstat_interface/interface/adc_pot.py
@@ -19,6 +19,7 @@
# along with this program. If not, see .
import gtk
+from parameters import ParametersGroup
v1_1_gain = [(0, "100 Ω (15 mA FS)", 0),
(1, "300 Ω (5 mA FS)", 1),
@@ -37,33 +38,55 @@ v1_2_gain = [(0, "Bypass", 0),
(5, "3 MΩ (500 nA FS)", 5),
(6, "30 MΩ (50 nA FS)", 6),
(7, "100 MΩ (15 nA FS)", 7)]
+
-class adc_pot:
+class adc_pot(object):
def __init__(self):
self.builder = gtk.Builder()
self.builder.add_from_file('interface/adc_pot.glade')
self.builder.connect_signals(self)
self.cell = gtk.CellRendererText()
+ # list of options
+ param_keys = []
+
self.buffer_toggle = self.builder.get_object('buffer_checkbutton')
+ param_keys.append(('adc_buffer_true',
+ self.buffer_toggle.get_active,
+ self.buffer_toggle.set_active))
self.short_toggle = self.builder.get_object('short_checkbutton')
-
+ param_keys.append(('pot_short_true',
+ self.short_toggle.get_active,
+ self.short_toggle.set_active))
+
#initialize comboboxes
self.pga_combobox = self.builder.get_object('pga_combobox')
self.pga_combobox.pack_start(self.cell, True)
self.pga_combobox.add_attribute(self.cell, 'text', 1)
self.pga_combobox.set_active(1)
+ param_keys.append(('adc_pga_index',
+ self.pga_combobox.get_active,
+ self.pga_combobox.set_active))
self.srate_combobox = self.builder.get_object('srate_combobox')
self.srate_combobox.pack_start(self.cell, True)
self.srate_combobox.add_attribute(self.cell, 'text', 1)
self.srate_combobox.set_active(7)
+ param_keys.append(('adc_srate_index',
+ self.srate_combobox.get_active,
+ self.srate_combobox.set_active))
self.gain_combobox = self.builder.get_object('gain_combobox')
self.gain_liststore = self.builder.get_object('gain_liststore')
self.gain_combobox.pack_start(self.cell, True)
self.gain_combobox.add_attribute(self.cell, 'text', 1)
self.gain_combobox.set_active(2)
+ param_keys.append(('pot_gain_index',
+ self.gain_combobox.get_active,
+ self.gain_combobox.set_active))
+
+ keys, getters, setters = zip(*param_keys)
+ self.param_group = ParametersGroup(keys, getters, setters)
def set_version(self, version):
""" Sets menus for DStat version. """
@@ -75,4 +98,5 @@ class adc_pot:
elif version[1] >= 2:
for i in v1_2_gain:
self.gain_liststore.append(i)
-
\ No newline at end of file
+
+
\ No newline at end of file
diff --git a/dstat_interface/interface/exp_int.py b/dstat_interface/interface/exp_int.py
old mode 100644
new mode 100755
index 2775dc7acd8dad05320f21bce94d704f863b8d4e..1ce2d1ef8a7c8a50f0e5d78843fa4f537862f7a0
--- a/dstat_interface/interface/exp_int.py
+++ b/dstat_interface/interface/exp_int.py
@@ -17,33 +17,35 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
-import os, sys
+import os
+import sys
+
import gtk
+import gobject
+
import dstat_comm
import __main__
-import gobject
from errors import InputError, VarError, ErrorLogger
_logger = ErrorLogger(sender="dstat-interface-exp_int")
+from parameters import ParametersGroup
class ExpInterface(object):
"""Generic experiment interface class. Should be subclassed to implement
- experiment interfaces by populating self.entry.
-
- Public methods:
- get_params(self)
+ experiment interfaces by populating self.entry and calling _init_params().
"""
def __init__(self, glade_path):
self.builder = gtk.Builder()
self.builder.add_from_file(glade_path)
self.builder.connect_signals(self)
- self.entry = {}
+ self.entry = {} # to be used only for str parameters
- def get_params(self):
- """Returns a dict of parameters for experiment."""
- parameters = {}
+ def _init_params(self, param_keys=[]):
+ """Initializes a dict of parameters for experiment."""
for key, value in self.entry.iteritems():
- parameters[key] = int(value.get_text())
- return parameters
+ param_keys.append((key, value.get_text, value.set_text))
+
+ keys, getters, setters = zip(*param_keys)
+ self.param_group = ParametersGroup(keys, getters, setters)
class Chronoamp(ExpInterface):
"""Experiment class for chronoamperometry. Extends ExpInterface class to
@@ -114,6 +116,18 @@ class Chronoamp(ExpInterface):
parameters['time'] = [int(r[1]) for r in self.model]
return parameters
+
+ def set_params(self, parameters):
+ """Loads a dict of parameters for experiment. Overrides superclass
+ method.
+ """
+
+ self.model.clear()
+
+ table = zip(parameters['potential'], parameters['time'])
+
+ for i in table:
+ self.model.append(i)
class LSV(ExpInterface):
"""Experiment class for LSV."""
@@ -129,6 +143,8 @@ class LSV(ExpInterface):
self.entry['stop'] = self.builder.get_object('stop_entry')
self.entry['slope'] = self.builder.get_object('slope_entry')
+ self._init_params()
+
class CV(ExpInterface):
"""Experiment class for CV."""
def __init__(self):
@@ -144,6 +160,8 @@ class CV(ExpInterface):
self.entry['v2'] = self.builder.get_object('v2_entry')
self.entry['slope'] = self.builder.get_object('slope_entry')
self.entry['scans'] = self.builder.get_object('scans_entry')
+
+ self._init_params()
class SWV(ExpInterface):
"""Experiment class for SWV."""
@@ -162,14 +180,15 @@ class SWV(ExpInterface):
self.entry['freq'] = self.builder.get_object('freq_entry')
self.entry['scans'] = self.builder.get_object('scans_entry')
- def get_params(self):
- """Extends superclass method to pass status of cyclic_checkbutton"""
- parameters = {}
- parameters['cyclic_checkbutton'] = self.builder.get_object(
- 'cyclic_checkbutton').get_active()
- parameters.update(super(SWV, self).get_params())
-
- return parameters
+ param_keys = [
+ ('cyclic_checkbutton',
+ self.builder.get_object(
+ 'cyclic_checkbutton').get_active,
+ self.builder.get_object(
+ 'cyclic_checkbutton').set_active
+ )
+ ]
+ self._init_params(param_keys)
class DPV(ExpInterface):
"""Experiment class for DPV."""
@@ -188,6 +207,8 @@ class DPV(ExpInterface):
self.entry['period'] = self.builder.get_object('period_entry')
self.entry['width'] = self.builder.get_object('width_entry')
+ self._init_params()
+
class ACV(ExpInterface):
"""Experiment class for ACV."""
def __init__(self):
@@ -199,6 +220,8 @@ class ACV(ExpInterface):
self.entry['slope'] = self.builder.get_object('slope_entry')
self.entry['amplitude'] = self.builder.get_object('amplitude_entry')
self.entry['freq'] = self.builder.get_object('freq_entry')
+
+ self._init_params()
class PD(ExpInterface):
"""Experiment class for PD."""
@@ -206,11 +229,7 @@ class PD(ExpInterface):
"""Adds entry listings to superclass's self.entry dict"""
super(PD, self).__init__('interface/pd.glade')
- self.entry['voltage'] = self.builder.get_object('voltage_adjustment')
self.entry['time'] = self.builder.get_object('time_entry')
- self.entry['interlock'] = self.builder.get_object('interlock_button')
- self.entry['shutter'] = self.builder.get_object('shutter_button')
- self.entry['sync'] = self.builder.get_object('sync_button')
self.entry['sync_freq'] = self.builder.get_object('sync_freq')
self.entry['fft_start'] = self.builder.get_object('fft_entry')
self.entry['fft_int'] = self.builder.get_object('fft_int_entry')
@@ -223,6 +242,35 @@ class PD(ExpInterface):
['sync_button', 'sync_freq', 'fft_label', 'fft_entry', 'fft_label2',
'fft_int_entry']
)
+
+ param_keys = [
+ ('voltage',
+ self.builder.get_object(
+ 'voltage_adjustment').get_value,
+ self.builder.get_object(
+ 'voltage_adjustment').set_value
+ ),
+ ('interlock',
+ self.builder.get_object(
+ 'interlock_button').get_active,
+ self.builder.get_object(
+ 'interlock_button').set_active
+ ),
+ ('shutter',
+ self.builder.get_object(
+ 'shutter_button').get_active,
+ self.builder.get_object(
+ 'shutter_button').set_active
+ ),
+ ('sync',
+ self.builder.get_object(
+ 'sync_button').get_active,
+ self.builder.get_object(
+ 'sync_button').set_active
+ )
+ ]
+
+ self._init_params(param_keys)
def on_light_button_clicked(self, data=None):
__main__.MAIN.on_pot_stop_clicked()
@@ -272,19 +320,6 @@ class PD(ExpInterface):
for i in self.shutter_buttons:
i.set_sensitive(False)
- def get_params(self):
- """Returns a dict of parameters for experiment."""
- parameters = {}
- parameters['voltage'] = int(self.entry['voltage'].get_value())
- parameters['time'] = int(self.entry['time'].get_text())
- parameters['interlock'] = self.entry['interlock'].get_active()
- parameters['shutter'] = self.entry['shutter'].get_active()
- parameters['sync'] = self.entry['sync'].get_active()
- parameters['sync_freq'] = float(self.entry['sync_freq'].get_text())
- parameters['fft_start'] = float(self.entry['fft_start'].get_text())
- parameters['fft_int'] = float(self.entry['fft_int'].get_text())
-
- return parameters
class POT(ExpInterface):
"""Experiment class for Potentiometry."""
@@ -294,6 +329,8 @@ class POT(ExpInterface):
self.entry['time'] = self.builder.get_object('time_entry')
+ self._init_params()
+
class CAL(ExpInterface):
"""Experiment class for Calibrating gain."""
def __init__(self):
diff --git a/dstat_interface/interface/exp_window.py b/dstat_interface/interface/exp_window.py
old mode 100644
new mode 100755
index 0aebdb5fd2dc3290c6c465965182ffc0e032fc0a..4bda6f7eb496731a2841efd748e23b52657b3ab2
--- a/dstat_interface/interface/exp_window.py
+++ b/dstat_interface/interface/exp_window.py
@@ -61,4 +61,7 @@ class Experiments:
return True
def get_params(self, experiment):
- return self.classes[experiment].get_params()
\ No newline at end of file
+ return self.classes[experiment].param_group.parameters
+
+ def set_params(self, experiment, parameters):
+ self.classes[experiment].param_group.parameters = parameters
\ No newline at end of file
diff --git a/dstat_interface/interface/untitled.txt b/dstat_interface/interface/untitled.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/dstat_interface/parameters.py b/dstat_interface/parameters.py
new file mode 100755
index 0000000000000000000000000000000000000000..442a80b479fd49243c445b8bda0f876b2c93d726
--- /dev/null
+++ b/dstat_interface/parameters.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# DStat Interface - An interface for the open hardware DStat potentiostat
+# Copyright (C) 2014 Michael D. M. Dryden -
+# Wheeler Microfluidics Laboratory
+#
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see .
+
+from errors import ErrorLogger
+_logger = ErrorLogger(sender="dstat-interface-parameters")
+
+class ParametersGroup(object):
+ """A set of parameters with associated dict keys and methods
+ for setting and reading.
+
+ Parameters:
+ keys -- ordered list of parameter dict keys
+ getters -- ordered list of getter method instances
+ setters -- ordered list of setter method instances
+ """
+ def __init__(self, keys, getters, setters):
+ self.dict = zip(keys, getters, setters)
+
+ @property
+ def parameters(self):
+ self._parameters = {}
+ try:
+ for i in self.dict:
+ key, getter, setter = i
+ self._parameters[key] = getter()
+ return self._parameters
+ except IndexError as e:
+ _logger.error("Invalid parameter key: %s" % e, "WAR")
+
+ @parameters.setter
+ def parameters(self, params):
+ try:
+ for i in self.dict:
+ key, getter, setter = i
+ setter(params[key])
+ except IndexError as e:
+ _logger.error("Invalid parameter key: %s" % e, "WAR")
+
+
+# def load_params(obj_list, params):
+# """Loads parameters into gtk widgets.
+#
+# Arguments:
+# obj_list -- List of 2-tuples of key, instance method pairs.
+# params -- dict of parameters
+# """
+# try:
+# for i in obj_list:
+# key, method = i
+# method(params[key])
+# except IndexError as e:
+# _logger.error("Invalid parameter key: %s" % e, "WAR")
+#
+# def save_params(obj_list):
+# """Saves params to dict.
+#
+# Arguments:
+# obj_list
+# """
+# pass
+
\ No newline at end of file