From 1b2430ce5e5102a436af6c022ba39e471228ab9b Mon Sep 17 00:00:00 2001 From: "Michael D. M. Dryden" Date: Tue, 22 Mar 2016 19:57:49 -0400 Subject: [PATCH] Started working on simplified parameter fetching/setting. --- dstat_interface/interface/adc_pot.py | 30 ++++++- dstat_interface/interface/exp_int.py | 111 ++++++++++++++++-------- dstat_interface/interface/exp_window.py | 5 +- dstat_interface/interface/untitled.txt | 0 dstat_interface/parameters.py | 78 +++++++++++++++++ 5 files changed, 183 insertions(+), 41 deletions(-) mode change 100644 => 100755 dstat_interface/interface/adc_pot.py mode change 100644 => 100755 dstat_interface/interface/exp_int.py mode change 100644 => 100755 dstat_interface/interface/exp_window.py create mode 100644 dstat_interface/interface/untitled.txt create mode 100755 dstat_interface/parameters.py diff --git a/dstat_interface/interface/adc_pot.py b/dstat_interface/interface/adc_pot.py old mode 100644 new mode 100755 index 6fdbd59..751c9ca --- 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 2775dc7..1ce2d1e --- 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 0aebdb5..4bda6f7 --- 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 0000000..e69de29 diff --git a/dstat_interface/parameters.py b/dstat_interface/parameters.py new file mode 100755 index 0000000..442a80b --- /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 -- GitLab