# ***************************************************************************** # 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 2 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, write to the Free Software Foundation, Inc., # 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # Module authors: # Markus Zolliker # ***************************************************************************** """frappy support for ultrasound""" import math import os import time import numpy as np from frappy_psi.adq_mr import Adq, PEdata, RUSdata from frappy.core import Attached, BoolType, Done, FloatRange, HasIO, StatusType, \ IntRange, Module, Parameter, Readable, Writable, Drivable, StringIO, StringType, \ IDLE, BUSY, DISABLED, WARN, ERROR, TupleOf, ArrayOf, Command, Attached, EnumType from frappy.properties import Property # from frappy.modules import Collector Collector = Readable def fname_from_time(t, extension): tm = time.localtime(t) dirname = os.path.join('..', 'data', time.strftime("%Y-%m-%d_%H", tm)) filename = time.strftime("%Y-%m-%d_%H-%M-%S_", tm) filename = filename + ("%.1f" % t)[-1] if not os.path.isdir(dirname): os.makedirs(dirname) return os.path.join(dirname, filename) class Roi(Readable): main = Attached() value = Parameter('amplitude', FloatRange(), default=0) phase = Parameter('phase', FloatRange(unit='deg'), default=0) i = Parameter('in phase', FloatRange(), default=0) q = Parameter('out of phase', FloatRange(), default=0) time = Parameter('start time', FloatRange(unit='nsec'), readonly=False) size = Parameter('interval (symmetric around time)', FloatRange(unit='nsec'), readonly=False) enable = Parameter('calculate this roi', BoolType(), readonly=False, default=True) pollinterval = Parameter(export=False) interval = (0, 0) def initModule(self): super().initModule() self.main.register_roi(self) self.calc_interval() def calc_interval(self): self.interval = (self.time - 0.5 * self.size, self.time + 0.5 * self.size) def read_status(self): return (IDLE, '') if self.enable else (DISABLED, 'disabled') def write_time(self, value): self.time = value self.calc_interval() return Done def write_size(self, value): self.size = value self.calc_interval() return Done class Pars(Module): description = 'relevant parameters from SEA' timestamp = Parameter('unix timestamp', StringType(), default='0', readonly=False) temperature = Parameter('T', FloatRange(unit='K'), default=0, readonly=False) mf = Parameter('field', FloatRange(unit='T'), default=0, readonly=False) sr = Parameter('rotation angle', FloatRange(unit='deg'), default=0, readonly=False) class FreqStringIO(StringIO): end_of_line = '\r' class Frequency(HasIO, Writable): value = Parameter('frequency', unit='Hz') amp = Parameter('amplitude (VPP)', FloatRange(unit='V'), readonly=False) output = Parameter('output: L or R', EnumType(L=1, R=0), readonly=False, default='L') last_change = 0 ioClass = FreqStringIO dif = None _freq = None def register_dif(self, dif): self.dif = dif def read_value(self): if self._freq is None: self._freq = float(self.communicate('FREQ?')) return self._freq def write_target(self, value): self._freq = float(self.communicate('FREQ %.15g;FREQ?' % value)) self.last_change = time.time() if self.dif: self.dif.read_value() self.read_value() return self._freq def write_amp(self, amp): reply = self.communicate(f'AMP{self.output.name} {amp} VPP;AMP{self.output.name}? VPP') return float(reply) def read_amp(self): reply = self.communicate(f'AMP{self.output.name}? VPP') return float(reply) class FrequencyDif(Readable): freq = Attached(Frequency) base = Parameter('base frequency', FloatRange(unit='Hz'), default=0) value = Parameter('difference to base frequency', FloatRange(unit='Hz'), default=0) def initModule(self): super().initModule() self.freq.register_dif(self) def read_value(self): return self.freq - self.base class Base: freq = Attached() sr = Parameter('samples per record', datatype=IntRange(1, 1E9), default=16384) adq = None def shutdownModule(self): if self.adq: self.adq.deletecu() self.adq = None class PulseEcho(Base): value = Parameter("t, i, q, pulse curves", TupleOf(*[ArrayOf(FloatRange(), 0, 16283) for _ in range(4)]), default=[[]] * 4) nr = Parameter('number of records', datatype=IntRange(1, 9999), default=500) bw = Parameter('bandwidth lowpassfilter', datatype=FloatRange(unit='Hz'), default=10E6) control = Parameter('control loop on?', BoolType(), readonly=False, default=True) time = Parameter('pulse start time', FloatRange(unit='nsec'), readonly=False) size = Parameter('pulse length (starting from time)', FloatRange(unit='nsec'), readonly=False) pulselen = Parameter('adjusted pulse length (integer number of periods)', FloatRange(unit='nsec'), default=1) _starttime = None def initModule(self): super().initModule() self.adq = Adq() self.adq.init(self.sr, self.nr) self.roilist = [] def write_nr(self, value): self.adq.init(self.sr, value) def write_sr(self, value): self.adq.init(value, self.nr) def write_bw(self, value): self.adq.bw_cutoff = value def register_roi(self, roi): self.roilist.append(roi) # TODO: fix # def go(self): # self._starttime = time.time() # self.adq.start() def read_value(self): # TODO: data = self.get_data() if self.get_rawdata(): # new data available roilist = [r for r in self.roilist if r.enable] freq = self.freq.value gates = self.adq.gates_and_curves(self._data, freq, (self.time, self.time + self.size), [r.interval for r in roilist]) for i, roi in enumerate(roilist): roi.i = a = gates[i][0] roi.q = b = gates[i][1] roi.value = math.sqrt(a ** 2 + b ** 2) roi.phase = math.atan2(a, b) * 180 / math.pi return self.adq.curves # TODO: CONTROL # inphase = self.roilist[0].i # if self.control: # newfreq = freq + inphase * self.slope - self.basefreq # # step = sorted((-self.maxstep, inphase * self.slope, self.maxstep))[1] # if self.old: # fdif = freq - self.old[0] # idif = inphase - self.old[1] # if abs(fdif) >= self.minstep: # self.slope = - fdif / idif # else: # fdif = 0 # idif = 0 # newfreq = freq + self.minstep # self.old = (freq, inphase) # if self.skipctrl > 0: # do no control for some time after changing frequency # self.skipctrl -= 1 # elif self.control: # self.freq = sorted((self.freq - self.maxstep, newfreq, self.freq + self.maxstep))[1] CONTINUE = 0 GO = 1 DONE_GO = 2 WAIT_GO = 3 class RUS(Base, Collector): freq = Attached() imod = Attached(mandatory=False) qmod = Attached(mandatory=False) input_signal = Attached(mandatory=False) output_signal = Attached(mandatory=False) value = Parameter('averaged (I, Q) tuple', TupleOf(FloatRange(), FloatRange())) status = Parameter(datatype=StatusType(Readable, 'BUSY')) periods = Parameter('number of periods', IntRange(1, 9999), default=12) input_delay = Parameter('throw away everything before this time', FloatRange(unit='ns'), default=10000, readonly=False) input_range = Parameter('input range (taking in to account attenuation)', FloatRange(unit='V'), default=10, readonly=False) output_range = Parameter('output range', FloatRange(unit='V'), default=1, readonly=False) input_phase_stddev = Parameter('input signal quality', FloatRange(unit='rad'), default=0) output_phase_slope = Parameter('output signal phase slope', FloatRange(unit='rad/sec'), default=0) output_amp_slope = Parameter('output signal amplitude change', FloatRange(unit='1/sec'), default=0) input_amplitude = Parameter('input signal amplitude', FloatRange(unit='V'), default=0) output_amplitude = Parameter('output signal amplitude', FloatRange(unit='V'), default=0) phase = Parameter('phase', FloatRange(unit='deg'), default=0) amp = Parameter('amplitude', FloatRange(), default=0) continuous = Parameter('continuous mode', BoolType(), readonly=False, default=True) pollinterval = Parameter(datatype=FloatRange(0, 120), default=1) _starttime = None _iq = 0 _wait_until = 0 # deadline for returning to continuous mode _action = CONTINUE # one of CONTINUE, GO, DONE_GO, WAIT_GO _status = IDLE, 'no data yet' _busy = False # waiting for end of aquisition (not the same as self.status[0] == BUSY) def initModule(self): super().initModule() self.adq = Adq() self._ovr_rate = {} self.freq.addCallback('value', self.update_freq) # self.write_periods(self.periods) def update_freq(self, value): self.setFastPoll(True, 0.001) def doPoll(self): try: data = self.adq.get_data() except Exception as e: self.set_status(ERROR, repr(e)) self._busy = False self._action = WAIT_GO self.wait_until = time.time() + 2 return self.setFastPoll(False) if data: # this is new data self._data = data for chan in data.channels: if chan.ovr_rate: self._ovr_rate[chan.name] = chan.ovr_rate * 100 else: self._ovr_rate.pop(chan.name, None) qual = data.get_quality() if self.input_signal: self.input_signal.value = np.round(data.channels[0].binned, 3) if self.output_signal: self.output_signal.value = np.round(data.channels[1].binned, 3) self.input_phase_stddev = qual.input_stddev.imag self.output_phase_slope = qual.output_slope.imag self.output_amp_slope = qual.output_slope.real self.input_amplitude = data.inp.amplitude * self.input_range self.output_amplitude = data.out.amplitude * self.output_range self._iq = iq = data.iq * self.output_range / self.input_range self.phase = np.arctan2(iq.imag, iq.real) * 180 / np.pi self.amp = np.abs(iq) self.read_value() self.set_status(IDLE, '') elif self._busy: self._busy = False if self._action == DONE_GO: self.set_status(BUSY, 'acquiring') else: self.set_status(IDLE, 'acquiring') return if self._action == CONTINUE and self.continuous: self.start_acquisition() self.set_status(IDLE, 'acquiring') return if self._action == GO: self.start_acquisition() self._action = DONE_GO self.set_status(BUSY, 'acquiring') return if self._action == DONE_GO: self._action = WAIT_GO self._wait_until = time.time() + 2 self.set_status(IDLE, 'paused') return if self._action == WAIT_GO: if time.time() > self._wait_until: self._action = CONTINUE self.start_acquisition() self.set_status(IDLE, 'acquiring') def set_status(self, *status): self._status = status if self._status != self.status: self.read_status() def read_status(self): if self._ovr_rate and self._status[0] < WARN: return WARN, 'overrange on %s' % ' and '.join(self._ovr_rate) return self._status def read_value(self): if self.imod: self.imod.value = self._iq.real if self.qmod: self.qmod.value = self._iq.imag return self._iq.real, self._iq.imag @Command def go(self): """start aquisition""" if self._busy: self._action = GO else: self._action = DONE_GO self.start_acquisition() self._status = BUSY, 'acquiring' self.read_status() def start_acquisition(self): freq = self.freq.read_value() self.sr = round(self.periods * self.adq.sample_rate / freq) delay_samples = round(self.input_delay * self.adq.sample_rate * 1e-9) self.adq.init(self.sr + delay_samples, 1) self.adq.start(RUSdata(self.adq, freq, self.periods, delay_samples)) self._busy = True self.setFastPoll(True, 0.001) class Signal(Readable): value = Parameter('pulse', ArrayOf(FloatRange(), maxlen=9999)) class ControlLoop(Module): roi = Attached(Roi) maxstep = Parameter('max frequency step', FloatRange(unit='Hz'), readonly=False, default=10000) minstep = Parameter('min frequency step for slope calculation', FloatRange(unit='Hz'), readonly=False, default=4000) slope = Parameter('inphase/frequency slope', FloatRange(), readonly=False, default=1e6) # class Frequency(HasIO, Readable): # pars = Attached() # curves = Attached(mandatory=False) # maxy = Property('plot y scale', datatype=FloatRange(), default=0.5) # # value = Parameter('frequency@I,q', datatype=FloatRange(unit='Hz'), default=0) # basefreq = Parameter('base frequency', FloatRange(unit='Hz'), readonly=False) # nr = Parameter('number of records', datatype=IntRange(1,10000), default=500) # sr = Parameter('samples per record', datatype=IntRange(1,1E9), default=16384) # freq = Parameter('target frequency', FloatRange(unit='Hz'), readonly=False) # bw = Parameter('bandwidth lowpassfilter', datatype=FloatRange(unit='Hz'),default=10E6) # amp = Parameter('amplitude', FloatRange(unit='dBm'), readonly=False) # control = Parameter('control loop on?', BoolType(), readonly=False, default=True) # rusmode = Parameter('RUS mode on?', BoolType(), readonly=False, default=False) # time = Parameter('pulse start time', FloatRange(unit='nsec'), # readonly=False) # size = Parameter('pulse length (starting from time)', FloatRange(unit='nsec'), # readonly=False) # pulselen = Parameter('adjusted pulse length (integer number of periods)', FloatRange(unit='nsec'), default=1) # maxstep = Parameter('max frequency step', FloatRange(unit='Hz'), readonly=False, # default=10000) # minstep = Parameter('min frequency step for slope calculation', FloatRange(unit='Hz'), # readonly=False, default=4000) # slope = Parameter('inphase/frequency slope', FloatRange(), readonly=False, # default=1e6) # plot = Parameter('create plot images', BoolType(), readonly=False, default=True) # save = Parameter('save data', BoolType(), readonly=False, default=True) # pollinterval = Parameter(datatype=FloatRange(0,120))