def main():
args = get_args()
uut = args.uut[0]
uut_object = acq400_hapi.Acq400(uut)
nchan_site = int(uut_object.s1.NCHAN)
x = np.linspace(0, 6 * np.pi, 750)
y = np.sin(x)
y2 = np.concatenate((y, np.zeros(274)))
upper = y2 + 1
lower = y2 - 1
for chan in range(1, nchan_site + 1):
pv = epics.PV('{}:1:JDG:MU:{:02d}:V'.format(uut, chan))
pv.put(upper)
pv = epics.PV('{}:1:JDG:ML:{:02d}:V'.format(uut, chan))
pv.put(lower)
print("Finished site 1 CH{}".format(chan))
for chan in range(1, nchan_site + 1):
pv = epics.PV('{}:2:JDG:MU:{:02d}:V'.format(uut, chan))
pv.put(upper)
pv = epics.PV('{}:2:JDG:ML:{:02d}:V'.format(uut, chan))
pv.put(lower)
print("Finished site 2 CH{}".format(chan))
return None
def run_main():
uuts = []
if len(sys.argv) > 1:
for addr in sys.argv[1:]:
uuts.append(acq400_hapi.Acq400(addr))
else:
print("USAGE: acq1001_caploop UUT1 [UUT2 ..]")
sys.exit(1)
acq400_hapi.cleanup.init()
for uut in uuts:
if hasattr(uut.s0, 'TIM_CTRL_LOCK'):
print "LOCKDOWN {}".format(uut)
uut.s0.TIM_CTRL_LOCK = 1
shot_controller = acq400_hapi.ShotController(uuts)
try:
while True:
shot_controller.run_shot(soft_trigger=True)
acq400_hapi.cleanup.sleep(1.0)
except acq400_hapi.cleanup.ExitCommand:
print("ExitCommand raised and caught")
finally:
print("Finally, going down")
def load_awg(args):
uut = acq400_hapi.Acq400(args.uuts[0])
acq400_hapi.Acq400UI.exec_args_playtrg(uut, args)
with open(args.file, "rb") as fd:
uut.load_awg(file_extender(fd, args.awg_extend), autorearm=args.mode==2)
if args.soft_trigger:
uut.s0.soft_trigger = '1'
def run_shots(args):
uut = acq400_hapi.Acq400(args.uuts[0])
acq400_hapi.cleanup.init()
if args.capture > 0:
uut.s0.transient = 'POST=%d SOFT_TRIGGER=%d' % \
(args.post, 1 if args.trg == 'int' else 0)
shot_controller = acq400_hapi.ShotController([uut])
for sx in uut.modules:
uut.modules[sx].trg = '1,1,1' if args.trg == 'int' else '1,0,1'
if args.files == "@ALLFULLSCALE":
work = awg_data.AllFullScale(uut, args.nchan, args.awglen)
elif args.files != "":
work = awg_data.RunsFiles(uut, args.files.split(','))
else:
work = awg_data.RainbowGen(uut, args.nchan, args.awglen)
for ii in range(0, args.loop):
print("shot: %d" % (ii))
for f in work.load():
print("Loaded %s" % (f))
if args.capture > 0:
shot_controller.run_shot(
soft_trigger=True if args.trg == 'int' else False)
else:
raw_input("hit return when done")
def configure_shot(args):
uuts = [acq400_hapi.Acq400(u) for u in args.uuts]
for uut in uuts:
if hasattr(uut.s0, 'TIM_CTRL_LOCK'):
print "LOCKDOWN {}".format(uut)
uut.s0.TIM_CTRL_LOCK = 0
mset = sets.Set(uuts[0:2])
pre = intSI(args.pre)
post = intSI(args.post)
t_args = [
args.trg.split(' ')[0], "prepost" if pre > 0 else "post",
"falling" if "falling" in args.trg else "rising"
]
c_args = args.clk.split(' ')
if len(c_args) > 1:
c_args[1] = intSI(c_args[1])
if len(c_args) > 2:
c_args[2] = intSI(c_args[2])
c_args = [str(x) for x in c_args]
for u in uuts:
print("uut:%s" % u.uut)
for svn, svc in sorted(u.svc.items()):
svc.trace = 1
u.s0.transient = "PRE=%d POST=%d SOFT_TRIGGER=%d" % (pre, post, 1
if pre > 0 else 0)
if pre != 0:
u.s1.trg = "1,1,1"
u.s1.event0 = "1,0,1"
else:
u.s1.trg = "1,0,1"
u.s1.event0 = "0,0,0"
def init(self):
import acq400_hapi
MIN_FREQUENCY = 10000
uut = acq400_hapi.Acq400(self.node.data(), monitor=False)
uut.s0.set_knob('set_abort', '1')
if self.ext_clock.length > 0:
raise Exception('External Clock is not supported')
freq = int(self.freq.data())
# D-Tacq Recommendation: the minimum sample rate is 10kHz.
if freq < MIN_FREQUENCY:
raise MDSplus.DevBAD_PARAMETER(
" Sample rate should be greater or equal than 10kHz")
mode = self.trig_mode.data()
if mode == 'hard':
role = 'master'
trg = 'hard'
elif mode == 'soft':
role = 'master'
trg = 'soft'
else:
role = mode.split(":")[0]
trg = mode.split(":")[1]
print("Role is {} and {} trigger".format(role, trg))
if trg == 'hard':
trg_dx = 'd0'
elif trg == 'automatic':
trg_dx = 'd1'
elif trg == 'soft':
trg_dx = 'd1'
# USAGE sync_role {fpmaster|rpmaster|master|slave|solo} [CLKHZ] [FIN]
# modifiers [CLK|TRG:SENSE=falling|rising] [CLK|TRG:DX=d0|d1]
# modifiers [TRG=int|ext]
# modifiers [CLKDIV=div]
uut.s0.sync_role = '%s %s TRG:DX=%s' % (role, self.freq.data(), trg_dx)
# Fetching all calibration information from every channel.
uut.fetch_all_calibration()
coeffs = uut.cal_eslo[1:]
eoff = uut.cal_eoff[1:]
self.chans = []
nchans = uut.nchan()
for ii in range(nchans):
self.chans.append(getattr(self, 'INPUT_%3.3d' % (ii + 1)))
for ic, ch in enumerate(self.chans):
if ch.on:
ch.OFFSET.putData(float(eoff[ic]))
ch.COEFFICIENT.putData(float(coeffs[ic]))
self.running.on = True
thread = self.MDSWorker(self)
thread.start()
def configure_shot(args):
if len(args.uuts) % 2:
print("ERROR: must be an even number of uuts, minimum 2")
sys.exit(1)
uuts = [acq400_hapi.Acq400(u) for u in args.uuts]
pre = intSI(args.pre)
post = intSI(args.post)
t_args = [
args.trg.split(' ')[0], "prepost" if pre > 0 else "post",
"falling" if "falling" in args.trg else "rising"
]
c_args = args.clk.split(',')
print("c_args split on comma {}".format(c_args))
if len(c_args) > 1:
c_args[1] = intSI(c_args[1])
if len(c_args) > 2:
c_args[2] = intSI(c_args[2])
c_args = [str(x) for x in c_args]
for u in uuts:
print("uut:%s" % u.uut)
u.s0.trace = 1
u.s0.set_abort = 1
u.s0.transient = "PRE=%d POST=%d SOFT_TRIGGER=0" % (pre, post)
u.s0.acq1014_select_trg_src = ' '.join(t_args)
u.s0.acq1014_select_clk_src = ' '.join(c_args)
u.s0.trace = 0
def init(self):
import acq400_hapi
uut = acq400_hapi.Acq400(self.node.data(), monitor=False)
trig_types = ['hard', 'soft', 'automatic']
trg = self.trig_mode.data()
if trg == 'hard':
trg_dx = 0
elif trg == 'automatic':
trg_dx = 1
elif trg == 'soft':
trg_dx = 1
# The default case is to use the trigger set by sync_role.
if self.trig_mode.data() == 'role_default':
uut.s0.sync_role = "%s %s" % (self.role.data(), self.freq.data())
else:
# If the user has specified a trigger.
uut.s0.sync_role = '%s %s TRG:DX=%s' % (self.role.data(),
self.freq.data(), trg_dx)
# Now we set the trigger to be soft when desired.
if trg == 'soft':
uut.s0.transient = 'SOFT_TRIGGER=0'
if trg == 'automatic':
uut.s0.transient = 'SOFT_TRIGGER=1'
uut.s0.transient = "POST=%s" % (self.samples.data())
def __init__(self, dev):
super(_ACQ400_ST_BASE.MDSWorker, self).__init__(name=dev.path)
import acq400_hapi
threading.Thread.__init__(self)
self.dev = dev.copy()
self.chans = []
self.decim = []
# self.nchans = self.dev.sites*32
uut = acq400_hapi.Acq400(self.dev.node.data())
self.nchans = uut.nchan()
for i in range(self.nchans):
self.chans.append(getattr(self.dev, 'INPUT_%3.3d' % (i + 1)))
self.decim.append(
getattr(self.dev, 'INPUT_%3.3d:DECIMATE' % (i + 1)).data())
self.seg_length = self.dev.seg_length.data()
self.segment_bytes = self.seg_length * self.nchans * np.int16(
0).nbytes
self.empty_buffers = Queue()
self.full_buffers = Queue()
for i in range(self.NUM_BUFFERS):
self.empty_buffers.put(bytearray(self.segment_bytes))
self.device_thread = self.DeviceWorker(self)
def configure_bm(args):
uuts = [acq400_hapi.Acq400(u) for u in args.uuts]
for u in uuts:
u.s0.trace = args.trace
u.s1.trace = args.trace
u.s0.GPG_ENABLE = '0' # needed if running set.burst multiple times
u.clear_counters() # makes COUNTERS opi easier to read
u.s0.transient = 'POST={}'.format(args.post)
u.s1.trg = args.trg
u.s1.RGM = args.rgm
u.s1.RGM_DX = args.dx
u.s1.RGM_SENSE = args.sense
u.s1.RTM_TRANSLEN = args.rtm_translen if args.rgm == 'RTM' else 0
u.s1.es_enable = args.es_enable
u.s0.set_knob(
'SIG_SRC_TRG_1',
'GPG1' if args.gpg == 'on' and args.dx == 'd1' else 'STRIG')
u.s0.set_knob(
'SIG_SRC_TRG_0', 'GPG0' if args.gpg == 'on' and args.dx == 'd0'
else 'HDMI_TRG' if args.hdmi_slave == 'yes' else 'EXT')
u.s0.set_arm = 1
for u in uuts:
u.statmon.wait_armed()
# warning: this is a RACE for the case of a free-running trigger and multiple UUTs
if args.gpg == 'on':
for u in uuts:
u.s0.GPG_ENABLE = '1'
if args.trg == '1,1,1':
for u in uuts:
u.s0.soft_trigger
def main():
parser = argparse.ArgumentParser(description='Streaming RTM')
parser.add_argument('--rtm_translen',
default=4096,
type=int,
help='How many samples to capture after each trigger.')
parser.add_argument('--data_dir', default='default', type=str,
help='Where to store your data. If left as default then data will be' \
' stored under [uut_name]_[datetime]')
parser.add_argument('uut', nargs='+', help="Name of uut to stream.")
args = parser.parse_args()
uut = acq400_hapi.Acq400(args.uut[0])
if args.data_dir == 'default':
args.data_dir = './' + args.uut[0] + '_' + datetime.datetime.now(
).strftime("%y%m%d%H%M") + '/'
print(args.data_dir)
nchan = uut.nchan()
#configure_uut(args, uut)
create_data_dir(args)
#uut.stream(FileSink(args))
uut.stream(FileSinkFun(args))
return None
def run_capture(args):
uuts = [acq400_hapi.Acq400(u) for u in args.uuts]
shot = set_next_shot(args, even, "Cap")
for u in uuts:
u.s0.transient = "POST={} SOFT_TRIGGER=0".format(args.post)
if args.trg == "ext rising" or args.trg == "ext":
u.s1.trg = "1,0,1"
elif args.trg == "ext falling":
u.s1.trg = "1,0,0"
for u in uuts:
u.s0.set_arm = '1'
for u in uuts:
u.statmon.wait_armed()
if args.trg == "int":
# again, not really parallel
for u in uuts:
print("trigger")
u.s0.soft_trigger = '1'
for u in uuts:
u.statmon.wait_stopped()
def run_shots(args):
uuts = [acq400_hapi.Acq400(u) for u in args.uuts]
acq400_hapi.cleanup.init()
for uut in uuts:
uut.s1.shot = 0
if hasattr(uut.s0, 'TIM_CTRL_LOCK'):
print "LOCKDOWN {}".format(uut)
uut.s0.TIM_CTRL_LOCK = 1
shot_controller = acq400_hapi.ShotController(uuts)
shot = 0
if args.trigger_uut != None:
_remote_trigger = RemoteTrigger(args.trigger_uut)
_soft_trigger = False
else:
_remote_trigger = None
_soft_trigger = True
try:
while shot < args.nshots:
print("shot {} of {}".format(shot, args.nshots))
shot_controller.run_shot(remote_trigger=_remote_trigger,
soft_trigger=_soft_trigger)
shot += 1
except acq400_hapi.cleanup.ExitCommand:
print("ExitCommand raised and caught")
finally:
print("Finally, going down")
def make_device(tname, args):
# Hostname is how the device will be accessed over the network.
# If the hostname argument is left as default then the tree argument
# will be used instead. This will only work if the tree is named after the
# acq400 device e.g. if the tree is called acq2106_xxx.
hostname = tname if args.hostname == 'default' else args.hostname
tree = MDSplus.Tree(tname, -1, "NEW")
uut = acq400_hapi.Acq400(hostname)
nchan = uut.nchan()
# Checks whether we're creating a device for acq1001 or acq2106.
carrier_type = uut.s0.MODEL[0:7]
# e.g. acq2106_32_tr for 32 channel acq2106 in transient capture mode.
model = "{}_{}_{}".format(carrier_type, args.model, nchan)
print("pgm: call tree.addDevice({}, {})".format(args.devname, model))
tree.addDevice(args.devname, model)
tree.write()
tree = MDSplus.Tree(tname, -1, "EDIT")
# Change node name to tree name
node = tree.getNode(args.devname).getNode("node")
node.putData(str(hostname))
# Create pulse 0.
MDSplus.Tree.setCurrent(tname, 1)
MDSplus.Tree(tname, -1).createPulse(1)
tree.write()
return None
def run_shot(args):
uuts = [acq400_hapi.Acq400(u) for u in args.uuts]
master = uuts[0]
acq400_hapi.cleanup.init()
for uut in uuts:
if args.transient != 'notouch':
uut.s0.transient = args.transient.replace(',', ' ')
# if hasattr(uut.s0, 'TIM_CTRL_LOCK'):
# print("LOCKDOWN {}".format(uut))
# uut.s0.TIM_CTRL_LOCK = 1
if args.hard_trigger_src is not None:
master.disable_trigger()
shot_controller = acq400_hapi.ShotController(uuts)
try:
rt = None if args.hard_trigger_src is None else selects_trg_src(
uuts[0], args.hard_trigger_src)
st = args.soft_trigger
shot_controller.run_shot(soft_trigger=st, remote_trigger=rt)
acq400_hapi.cleanup.sleep(1.0)
except acq400_hapi.cleanup.ExitCommand:
print("ExitCommand raised and caught")
finally:
print("Finally, going down")
def run_awg(args):
uut = acq400_hapi.Acq400(args.uuts[0])
get_distributor_sites(args, uut)
wavelen = args.length * 2 * args.nchan
bufferlen = int(uut.s0.bufferlen)
if wavelen <= MINBUFFERS * bufferlen:
play_bufferlen = int(wavelen / MINBUFFERS)
else:
# pick larges buffer such than nbuffers is an even number
nbuffers = int(np.ceil(wavelen / bufferlen))
if nbuffers % 2 != 0:
nbuffers += 1
play_bufferlen = int(wavelen / nbuffers)
while play_bufferlen & 7 and nbuffers < 20:
nbuffers += 2
play_bufferlen = int(wavelen / nbuffers)
wl_act = play_bufferlen * nbuffers
print("wavelen {} play_bufferlen {} nbuffers {} p*n {} {}".\
format(wavelen, play_bufferlen, nbuffers, wl_act, "OK" if wl_act == wavelen else "UNEQUAL"))
uut.s0.dist_bufferlen_play = play_bufferlen
configure_master_site(args, uut)
if args.burst_length == args.length:
load_burstlen_equals_wavelen(args, uut)
else:
load_multiple_bursts_in_one_wavelen(args, uut)
def run_shots(args):
uut = acq400_hapi.Acq400(args.uuts[0])
acq400_hapi.cleanup.init()
uut.s0.transient = 'POST=%d SOFT_TRIGGER=%d DEMUX=%d' % \
(args.post, 1 if args.trg == 'int' else 0, 1 if args.store==0 else 0)
if args.aochan == 0:
args.aochan = args.nchan
for sx in uut.modules:
uut.modules[sx].trg = '1,1,1' if args.trg == 'int' else '1,0,1'
if args.files != "":
work = awg_data.RunsFiles(uut, args.files.split(','), True)
else:
work = awg_data.RainbowGen(uut, args.aochan, args.awglen, True)
store = store_file
loader = work.load()
for ii in range(0, args.loop):
print("shot: %d" % (ii))
f = loader.next()
print("Loaded %s" % (f))
uut.run_oneshot()
if args.store:
print("read_chan %d" % (args.post*args.nchan))
rdata = uut.read_chan(0, args.post*args.nchan)
store(ii, rdata, args.nchan, args.post)
if args.wait_user:
raw_input("hit return to continue")
def run_test(args):
# Setup
uut = acq400_hapi.Acq400(args.uuts[0])
uut.s1.trg = "1,1,1" # use soft trigger
skt = socket.socket()
rxbuf_len = 4096
data = ""
counter = 1
args.nchan = int(uut.s0.NCHAN) if args.nchan == -1 else args.nchan
print args.nchan
while counter < args.loops:
print "Starting loop: ", counter
# Start stream
skt = socket.socket()
skt.connect((args.uuts[0], 4210))
while sys.getsizeof(data) < (1024**2): # pull 1MB
data += skt.recv(rxbuf_len)
skt.close()
# Get numpy array from string data
data = np.frombuffer(bytes(data), dtype=args.data_type)
if args.verify == 1:
verify_spad(args, data)
# plt.plot(data[0::args.nchan])
# plt.show()
data = ""
print "Successfully finished loop: ", counter
counter += 1
time.sleep(1)
return None
def run_shot(args):
master = acq400_hapi.Acq400(args.uuts[0])
if args.enable_trigger:
master.enable_trigger()
return
args.postfix = [] # master specials
postfix = [] # common specials
if args.clkdiv:
args.postfix.append("CLKDIV={}".args.clkdiv)
master.s0.sync_role = "{} {} {} {}".format(expand_role(args, args.toprole),
args.fclk, args.fin,
" ".join(args.postfix), " ".join(postfix))
if args.external_trigger:
master.disable_trigger()
else:
# print("WARNING: REMOVEME temporary fudge while we get the sync trigger right")
# master.s0.SIG_SYNC_OUT_TRG_DX = 'd1'
print("")
# enable_trigger(master)
# now run all the slave in parallel. We can do this because they do not share data.
threads = []
for uutname in args.uuts[1:]:
t = threading.Thread(target=configure_slave, args=(uutname, args, postfix))
threads.append(t)
t.start()
for t in threads:
t.join()
def upload(args):
uuts = [acq400_hapi.Acq400(u) for u in args.uuts]
acq400_hapi.cleanup.init()
shot_controller = acq400_hapi.ShotController(uuts)
if args.remote_trigger:
trigger_action = ActionScript(args.remote_trigger)
st = None
else:
trigger_action = None
st = SOFT_TRIGGER
try:
if args.capture:
shot_controller.run_shot(soft_trigger=st,
remote_trigger=trigger_action)
else:
state = '99'
while state != '0':
state = uuts[0].s0.state.split()[0]
print("state:{}".format(state))
if state == '1':
if trigger_action:
trigger_action()
elif st:
uut.s0.soft_trigger = '1'
time.sleep(1)
if args.save_data:
for u in uuts:
u.save_data = args.save_data
if args.trace_upload:
for u in uuts:
u.trace = 1
chx, ncol, nchan, nsam = shot_controller.read_channels(
eval(args.channels))
# plot ex: 2 x 8 ncol=2 nchan=8
# U1 U2 FIG
# 11 21 1 2
# 12 22 3 4
# 13 23
# ...
# 18 28 15 16
if PLOTDATA:
for col in range(ncol):
for chn in range(0, nchan):
fignum = 1 + col + chn * ncol
plt.subplot(nchan, ncol, fignum)
plt.plot(chx[col][chn])
plt.show()
except acq400_hapi.cleanup.ExitCommand:
print("ExitCommand raised and caught")
finally:
print("Finally, going down")
def tee_adc(uut_name, burstlen):
print(
"tee_adc {} .. we assume it's ready to go with a triggered transient".
format(uut_name))
uut = acq400_hapi.Acq400(uut_name)
uut.s1.RTM_TRANSLEN = burstlen
uut.s0.TRANSIENT_SET_ARM = 1
uut.s0.TRANSIENT_SET_ARM = 0
def arm(self):
import acq400_hapi
uut = acq400_hapi.Acq400(self.node.data())
shot_controller = acq400_hapi.ShotController([uut])
if self.debug:
print("Using HAPI ShotController to run the shot.")
shot_controller.run_shot()
def run_cal(args):
uuts = [acq400_hapi.Acq400(u) for u in args.uuts]
shot = set_next_shot(args, odd, "Cal")
# hmm, running the cal serialised?. not cool, parallelize me ..
for u in uuts:
run_cal1(u, shot)
# unfortunately this sleep seems to be necessary, else subsequent shot HANGS at 21760
time.sleep(2)
def run_main():
parser = argparse.ArgumentParser(description='cs demux')
parser.add_argument('--SHORTCOLS', default=16, type=int, help="number of shorts cols")
parser.add_argument('--LONGCOLS', default=4, type=int, help="number of longs cols")
parser.add_argument('--plot', default=1, type=int, help="Plot data")
parser.add_argument('--save', default=0, type=int, help="Save data")
parser.add_argument('--show_transitions', default=0, type=int, help="hexdump +/-N samples at transition")
parser.add_argument('--data_file', default=None, type=str, help="Name of data file")
parser.add_argument('--get_oneshot', default=None, type=str, help="[uut] pull oneshot data")
parser.add_argument('--get_next', default=None, type=str, help="[uut] get next mv file from uut")
parser.add_argument('--get_count', default=1, type=int, help="number of event files to fetch")
parser.add_argument('--get_stick', default=1, type=int, help="1: get data from USB stick, 0: from /tmp")
args = parser.parse_args()
args.SAMPLE_SIZE = int(args.SHORTCOLS*2 + args.LONGCOLS*4)
args.SAMPLE_SIZE_SHORTS = int(args.SHORTCOLS + 2*args.LONGCOLS)
args.SAMPLE_SIZE_LONGS = int(args.SHORTCOLS//2 + args.LONGCOLS)
args.L0 = int(args.SHORTCOLS//2)
args.fn = "save_file"
args.uut = None
first_time = True
if not args.get_next:
args.get_count = 0
while first_time or args.get_count > 0:
if args.get_oneshot:
args.uut = acq400_hapi.Acq400(args.get_oneshot)
args.save = 1
args.get_count = 0
uut_get_oneshot(args, args.uut)
elif args.get_next:
args.uut = acq400_hapi.Acq400(args.get_next)
args.save = 1
uut_get_next(args, args.uut)
args.get_count = args.get_count - 1
elif args.data_file:
data = load_data(args)
if args.show_transitions > 0:
show_transitions(args)
if args.plot == 1:
plot_data(args)
if args.save == 1:
save_data(args)
first_time = False
def load_dpg(args):
uut = acq400_hapi.Acq400(args.uut[0])
with open(args.file, "r") as stl_file:
stl = stl_file.read()
print(stl)
uut.load_dpg(stl)
return None
def configure_shot(args):
acq400_configure_transient.configure_shot(args)
sync_role.run_shot(args)
uuts = [acq400_hapi.Acq400(u) for u in args.uuts]
for uut in uuts:
uut.s0.transient = "DEMUX=1"
return uuts
def run_stream(args):
data = ""
num = 0
uuts = [acq400_hapi.Acq400(u) for u in args.uuts]
for uut in uuts:
try:
if uut.s0.data32:
wordsizetype = "<i4" # 32 bit little endian
except AttributeError:
print(
"Attribute error detected. No data32 attribute - defaulting to 16 bit"
)
wordsizetype = "<i2" # 16 bit little endian
skt = acq400_hapi.Netclient(args.uuts[0], 4210)
make_data_dir(args.root, args.verbose)
start_time = time.clock()
upload_time = time.clock()
data_length = 0
while time.clock() < (start_time +
args.runtime) and data_length < args.totaldata:
loop_time = time.clock()
data += skt.sock.recv(1024)
if len(data) / 1024 >= args.filesize:
data_length += float(len(data)) / 1024
data_file = open("{}/data{}.dat".format(args.root, num), "wb")
data = np.frombuffer(data, dtype=wordsizetype, count=-1)
data.tofile(data_file, '')
if args.verbose == 1:
print "New data file written."
print "Data Transferred: ", data_length, "KB"
print "loop_time: ", loop_time
print "Data upload & save rate: ", float(
len(data)) / 1024 / (
(time.clock() - upload_time)), "KB/s"
print ""
print ""
num += 1
data_file.close()
data = "" # Remove data from variable once it has been written
upload_time = time.clock() # Reset upload time
data_written_flag = 1
try:
data_written_flag
except NameError:
data_file = open("{}/data{}.dat".format(args.root, num), "wb")
data = np.frombuffer(data, dtype=wordsizetype, count=-1)
data.tofile(data_file, '')
print "runtime exceeded: all stream data written to single file"
def acq400_configure_transient_config_and_execute():
print("acq400_configure_transient_config_and_execute")
parser = argparse.ArgumentParser(
description="configure single or multiple acq400")
acq400_hapi.Acq400UI.add_args(parser, transient=True)
argString = '--pre=0 --post=100000 --trg=int,rising {}'.format(
DEFAULTS.uutIPAddress[0])
args = acq400_configure_transient.get_args(shlex.split(argString))
acq400_configure_transient.configure_shot(
args, [acq400_hapi.Acq400(u) for u in args.uuts])
def run_main():
uuts = []
if len(sys.argv) > 1:
for addr in sys.argv[1:]:
uuts.append(acq400_hapi.Acq400(addr))
else:
print("USAGE: acq1014_check_config UUT1 [UUT ...]")
for uut in uuts:
uut.s0.reboot = "3210"
def run_shot(args):
uuts = [acq400_hapi.Acq400(u) for u in args.uuts]
try:
uuts[0].statmon.wait_stopped()
except acq400_hapi.cleanup.ExitCommand:
print("ExitCommand raised and caught")
finally:
print("Finally, going down")
