class PspepsIO(TargetIO):
def __init__(self, **kwargs):
self.viewer = kwargs.get('viewer', None)
super(PspepsIO, self).__init__(**kwargs)
def get_plot_mode(self):
options = ['MP', 'IQ', 'RAW', 'FFT', 'FFT_IQ', 'Bode']
mode = options[0]
return (mode, options)
def start_io(self):
self.start_pspeps(self.config['ip'], int(self.config['port']),
self.config['id'], self.config['app_path'],
self.config.get('async', '1') == '1')
def start_pspeps(self,
ip_addr,
port,
firmware_id,
app_path,
use_async=True):
""" Demux different projects """
if app_path and firmware_id:
base_dir = os.path.dirname(os.path.abspath(__file__)) or '.'
import pkgutil
self.app_dir = os.path.join(base_dir, app_path)
if self.app_dir not in sys.path:
sys.path.insert(0, self.app_dir)
from app import Application
Window.set_title(firmware_id)
self.app = Application(ip=ip_addr, port=port, use_async=use_async)
self.clients = {}
for loader, name, ispkg in pkgutil.iter_modules(
path=[self.app_dir + '/clients']):
if not ispkg:
mtime = self.get_client_mtime(name)
self.clients[name] = (importlib.import_module('clients.' +
name), mtime)
self.client_options = self.clients.keys()
self.dispatch('on_start')
else:
Logger.error('No valid firmware_id found. Quit now...')
def load_client(self, name, mtime):
self.clients[name] = (reload(self.clients[name][0]), mtime)
def get_client_mtime(self, client_name):
return os.stat(self.app_dir + '/clients/' + client_name +
'.py').st_mtime
def stop_io(self, *args):
return self.app.stop_io()
def get_trace(self, plot_mode='MP', length=256, cal=False):
Logger.debug('getting trace with mode %s...' % plot_mode)
iq_mode = plot_mode in ['MP', 'IQ', 'FFT_IQ', 'Bode']
return self.app.get_waveform(iq_mode, length,
cal).addCallback(self.got_trace,
plot_mode)
def got_trace(self, dat, plot_mode):
if dat is not None:
Logger.debug('got_trace length %d, %s' %
(len(dat), datetime.now()))
self.dispatch('on_trace', dat, plot_mode)
return dat
def get_chassis_mon(self):
self.app.get_chassis_mon().addCallback(self.got_chassis_data,
'on_chassis_data')
def got_chassis_data(self, dat, event):
self.dispatch(event, dat)
return dat
def get_slow_data(self):
self.app.read_slow_buf().addCallback(self.got_slow_data)
def got_slow_data(self, dat):
if dat is not None:
self.dispatch('on_slowdata', dat)
return dat
def get_slow_raw_data(self):
self.app.read_slow_buf(decode=False).addCallback(
self.got_slow_raw_data)
def got_slow_raw_data(self, dat):
if dat is not None:
self.dispatch('on_slow_raw', dat)
return dat
def get_target_info(self):
self.app.get_config_rom().addCallback(self.got_config_rom)
def got_config_rom(self, dat):
self.dispatch('on_devinfo', dat)
return dat
def write_reg(self, reg_name, reg_val):
Logger.info('Updating register %s to value: %d' % (reg_name, reg_val))
self.app.write_app_reg_dict({reg_name: reg_val})
def get_reg_by_addr(self, addr):
return self.app.get_reg_by_addr(addr)
def write_regs(self, reg_list):
written_regs = self.app.write_regs(reg_list)
if self.viewer is not None:
for r in written_regs:
short_name = self.app.get_view_name(r.name)
if short_name in self.viewer.reg_view_dict:
self.viewer.reg_view_dict[short_name]['value'] = r.value
self.viewer.reg_view.update(self.viewer.reg_view_dict)
def get_init_regmap_dict(self):
return self.app.get_init_regmap_dict()
def get_time_step_adc(self):
return self.app.get_timestep_adc()
def set_xscale(self, val):
return self.app.set_xscale(val)
def get_xscale_value(self):
return self.app.get_wave_samp_per()
def get_xscale_range(self):
return self.app.get_wave_samp_per_range()
def get_xscale_enable(self):
return True
def calc_yscale(self, cal=False):
return self.app.calc_yscale(cal)
def set_cbuf_mode(self, mode):
Logger.info('Updating cbuf mode to: %s' % mode)
self.app.set_cbuf_mode(mode)
def get_chan_info(self):
return self.app.get_chan_info()
def set_chan_keep(self, chans):
return self.app.set_chan_keep_reg(chans)
def init_chassis(self):
self.app.init_chassis().addCallback(self.got_chassis_data,
'on_chassis_init')
def get_max_waveform_delay(self):
return self.app.get_cbuf_delay()
