def comedi_get_cmd_fast_1chan(dev,s,cmd):
ret = c.comedi_get_cmd_src_mask(dev,s,cmd)
if (ret<0): return ret;
cmd.chanlist_len = 1
cmd.scan_end_src = c.TRIG_COUNT
cmd.scan_end_arg = 1
if (cmd.convert_src & c.TRIG_TIMER):
if (cmd.scan_begin_src & c.TRIG_FOLLOW):
cmd.convert_src=c.TRIG_TIMER
cmd.scan_begin=c.TRIG_FOLLOW
else:
cmd.convert_src=c.TRIG_TIMER
cmd.scan_begin=c.TRIG_TIMER
else:
print("can't do timed!?!")
return -1
if (cmd.stop_src & c.TRIG_COUNT):
cmd.stop_src=c.TRIG_COUNT
cmd.stop_arg=2
elif (cmd.stop_src & c.TRIG_NONE):
cmd.stop_src=c.TRING_NONE
cmd.stop_arg=0
else:
print("can't find a good stop_src")
return -1
ret = c.comedi_command_test(dev,cmd)
if (ret==3):
ret = c.comedi_command_test(dev,cmd)
if ((ret==4) or (ret==0)):
return 0
return -1
def comedi_get_cmd_fast_1chan(dev, s, cmd):
ret = c.comedi_get_cmd_src_mask(dev, s, cmd)
if (ret < 0): return ret
cmd.chanlist_len = 1
cmd.scan_end_src = c.TRIG_COUNT
cmd.scan_end_arg = 1
if (cmd.convert_src & c.TRIG_TIMER):
if (cmd.scan_begin_src & c.TRIG_FOLLOW):
cmd.convert_src = c.TRIG_TIMER
cmd.scan_begin = c.TRIG_FOLLOW
else:
cmd.convert_src = c.TRIG_TIMER
cmd.scan_begin = c.TRIG_TIMER
else:
print "can't do timed!?!"
return -1
if (cmd.stop_src & c.TRIG_COUNT):
cmd.stop_src = c.TRIG_COUNT
cmd.stop_arg = 2
elif (cmd.stop_src & c.TRIG_NONE):
cmd.stop_src = c.TRING_NONE
cmd.stop_arg = 0
else:
print "can't find a good stop_src"
return -1
ret = c.comedi_command_test(dev, cmd)
if (ret == 3):
ret = c.comedi_command_test(dev, cmd)
if ((ret == 4) or (ret == 0)):
return 0
return -1
def test_cmd(self,cmd):
self.logger.info("Command before testing")
self.dump_cmd(cmd)
ret = c.comedi_command_test(self.dev,cmd)
temp_str = "First cmd test returns:", ret, self.cmdtest_messages[ret]
self.logger.info(temp_str)
self.dump_cmd(cmd)
if ret<0:
self.logger.error("comedi_command_test failed")
return -1
ret = c.comedi_command_test(self.dev,cmd)
temp_str = "Second cmd test returns:", ret, self.cmdtest_messages[ret]
self.logger.info(temp_str)
self.dump_cmd(cmd)
if ret<0:
self.logger.error("comedi_command_test failed")
return -1
return ret
def init_comedi_ao(aochAO, dt, nsamples):
sys.stdout.write("NICOMEDI: Initializing analog outputs... ")
sys.stdout.flush()
chansao = [aochAO]
chlistao = make_chlist(chansao)
cmdao = make_cmd_ao(aochAO.subdev, dt, chlistao, len(chansao), nsamples)
#test our comedi command a few times.
ntry = 0
while c.comedi_command_test(aochAO.dev, cmdao):
ntry += 1
if ntry>10:
raise Exception("NICOMEDI: Couldn't write to comedi AO device")
sys.stdout.write("done\n")
sys.stdout.flush()
return cmdao, chlistao
def init_comedi_ai(aichFR, aichIC, aichEC, dt):
sys.stdout.write("NICOMEDI: Initializing analog inputs... ")
sys.stdout.flush()
chansai = [aichIC, aichEC, aichFR]
chlistai = make_chlist(chansai)
cmdai = make_cmd(aichIC.subdev, dt, chlistai, len(chansai))
#test our comedi command a few times.
ntry = 0
while c.comedi_command_test(aichIC.dev,cmdai):
ntry += 1
if ntry>10:
raise Exception("NICOMEDI: Couldn't read from comedi AI device")
sys.stdout.write("done\n")
sys.stdout.flush()
return cmdai
def init_comedi_ao(aochAO, dt, nsamples):
sys.stdout.write("NICOMEDI: Initializing analog outputs... ")
sys.stdout.flush()
chansao = [aochAO]
chlistao = make_chlist(chansao)
cmdao = make_cmd_ao(aochAO.subdev, dt, chlistao, len(chansao), nsamples)
#test our comedi command a few times.
ntry = 0
while c.comedi_command_test(aochAO.dev, cmdao):
ntry += 1
if ntry > 10:
raise Exception("NICOMEDI: Couldn't write to comedi AO device")
sys.stdout.write("done\n")
sys.stdout.flush()
return cmdao, chlistao
def init_comedi_ai(aichFR, aichIC, aichEC, dt):
sys.stdout.write("NICOMEDI: Initializing analog inputs... ")
sys.stdout.flush()
chansai = [aichIC, aichEC, aichFR]
chlistai = make_chlist(chansai)
cmdai = make_cmd(aichIC.subdev, dt, chlistai, len(chansai))
#test our comedi command a few times.
ntry = 0
while c.comedi_command_test(aichIC.dev, cmdai):
ntry += 1
if ntry > 10:
raise Exception("NICOMEDI: Couldn't read from comedi AI device")
sys.stdout.write("done\n")
sys.stdout.flush()
return cmdai
## raise "Error fetching comedi max buff size"
## else:
## print "max buff size = ", ret
#construct a comedi command
cmd = c.comedi_cmd_struct()
cmd.chanlist = mylist # adjust for our particular context
cmd.chanlist_len = nchans
cmd.scan_end_arg = nchans
prepare_cmd(dev,subdevice,cmd)
print "command before testing"
dump_cmd(cmd)
#test our comedi command a few times.
ret = c.comedi_command_test(dev,cmd)
print "first cmd test returns ", ret, cmdtest_messages[ret]
if ret<0:
raise "comedi_command_test failed"
dump_cmd(cmd)
ret = c.comedi_command_test(dev,cmd)
print "second test returns ", ret, cmdtest_messages[ret]
if ret<0:
raise "comedi_command_test failed"
if ret !=0:
dump_cmd(cmd)
raise "ERROR preparing command"
dump_cmd(cmd)
front = 0
## else:
## print("max buff size = ", ret)
#construct a comedi command
cmd = c.comedi_cmd_struct()
cmd.chanlist = mylist # adjust for our particular context
cmd.chanlist_len = nchans
cmd.scan_end_arg = nchans
prepare_cmd(dev, subdevice, cmd)
print("command before testing")
dump_cmd(cmd)
#test our comedi command a few times.
ret = c.comedi_command_test(dev, cmd)
print "first cmd test returns ", ret, cmdtest_messages[ret]
if ret < 0:
raise Exception("comedi_command_test failed")
dump_cmd(cmd)
ret = c.comedi_command_test(dev, cmd)
print("second test returns ", ret, cmdtest_messages[ret])
if ret < 0:
raise Exception("comedi_command_test failed")
if ret != 0:
dump_cmd(cmd)
raise Exception("ERROR preparing command")
dump_cmd(cmd)
ret = c.comedi_command(dev, cmd)
def pci_6033e_init(self, dev_name):
self.dev = c.comedi_open(dev_name)
if not(self.dev):
self.warn_dialog("Unable to open device: " + dev_name)
return(-1)
ret = c.comedi_lock(self.dev, SUBDEVICE)
if (ret < 0):
self.warn_dialog("Could not lock comedi device")
return(-1)
# get a file-descriptor for use later
self.fd = c.comedi_fileno(self.dev)
if (self.fd <= 0):
self.warn_dialog("Error obtaining Comedi device file descriptor")
c.comedi_close(self.dev)
return(-1)
# Channel range (0-5V)
if (c.comedi_range_is_chan_specific(self.dev, SUBDEVICE) != 0):
self.warn_dialog("Comedi range is channel specific!")
c.comedi_close(self.dev)
return(-1)
self.comedi_range = c.comedi_get_range(self.dev, SUBDEVICE, 0, CHAN_RANGE)
self.comedi_maxdata = c.comedi_get_maxdata(self.dev, SUBDEVICE, 0)
board_name = c.comedi_get_board_name(self.dev)
if (board_name != "pci-6033e"):
print("Opened wrong device!")
# Prepare channels, gains, refs
self.comedi_num_chans = NUM_CHANNELS
chans = range(self.comedi_num_chans)
gains = [0]*self.comedi_num_chans
aref = [c.AREF_GROUND]*self.comedi_num_chans
chan_list = c.chanlist(self.comedi_num_chans)
# Configure all the channels!
for i in range(self.comedi_num_chans):
chan_list[i] = c.cr_pack(chans[i], gains[i], aref[i])
# The comedi command
self.cmd = c.comedi_cmd_struct()
# 1.0e9 because this number is in nanoseconds for some reason
period = int(1.0e9/float(SCAN_FREQ))
# Init cmd
ret = c.comedi_get_cmd_generic_timed(self.dev, SUBDEVICE, self.cmd, self.comedi_num_chans, period)
if (ret):
self.warn_dialog("Could not initiate command")
c.comedi_close(self.dev)
return(-1)
# Populate command
self.cmd.chanlist = chan_list
self.cmd.chanlist_len = self.comedi_num_chans
self.cmd.scan_end_arg = self.comedi_num_chans
self.cmd.stop_src = c.TRIG_NONE
self.cmd.stop_arg = 0
print("real timing: %d ns" % self.cmd.convert_arg)
print("Real scan freq: %d Hz" % (1.0/(float(self.cmd.convert_arg)*32.0*1.0e-9)))
#print("period: %d ns" % period)
print_cmd(self.cmd)
# Test command out.
ret = c.comedi_command_test(self.dev, self.cmd)
if (ret < 0):
self.warn_dialog("Comedi command test failed!")
c.comedi_close(self.dev)
return(-1)
print("Command test passed")
return(0)
def acquire_data(config):
"""
Acquire data from data acquisition device.
"""
#Open a comedi device
dev = c.comedi_open(config['device'])
if not dev:
err_msg = "%s: error: unable to open openning Comedi device" % (
PROG_NAME, )
sys.stderr.write(err_msg)
sys.exit(1)
# Get a file-descriptor to access data
fd = c.comedi_fileno(dev)
# Setup channels
nchans = len(config['channels'])
aref_str = config['aref'].lower()
if aref_str == 'diff':
aref = [c.AREF_DIFF] * nchans
elif aref_str == 'common':
aref = [c.AREF_COMMON] * nchans
elif aref_str == 'ground':
aref = [c.AREF_GROUND] * nchans
else:
raise ValueError, 'unknown aref'
#nchans = len(config['channels'])
#aref =[c.AREF_GROUND]*nchans
# Pack the channel, gain and reference information into the chanlist object
channel_list = c.chanlist(nchans)
for i in range(nchans):
channel_list[i] = c.cr_pack(config['channels'][i], config['gains'][i],
aref[i])
# Construct a comedi command
cmd = c.comedi_cmd_struct()
cmd.subdev = config['subdev']
cmd.flags = DEFAULT_CMD_FLAGS
cmd.start_src = c.TRIG_NOW
cmd.sart_arg = DEFAULT_CMD_SART_ARG
cmd.scan_begin_src = c.TRIG_TIMER
cmd.scan_begin_arg = int(NANO_SEC / config['sample_freq'])
cmd.convert_src = c.TRIG_TIMER
cmd.convert_arg = DEFAULT_CMD_CONVERT_ARG
cmd.scan_end_src = c.TRIG_COUNT
cmd.scan_end_arg = nchans
cmd.stop_src = c.TRIG_COUNT
cmd.stop_arg = config['sample_num']
cmd.chanlist = channel_list
cmd.chanlist_len = nchans
# Test comedi command
if config['verbose']:
print 'Testing comedi command'
print
for i in range(0, DEFAULT_CMD_TEST_NUM):
if config['verbose']:
print_cmd(cmd)
ret = c.comedi_command_test(dev, cmd)
if config['verbose']:
print
print '\t*** test %d returns %s' % (i, CMD_TEST_MSG[ret])
print
if not ret == 0:
msg_data = (PROG_NAME, CMD_TEST_MSG[ret])
err_msg = '%s: error: unable to configure daq device - %s' % msg_data
sys.stderr.write(err_msg)
# Acquire data
if config['verbose']:
print 'acquiring data'
print
sys.stdout.flush()
ret = c.comedi_command(dev, cmd) # non blocking
if not ret == 0:
err_msg = '%s: error: unable to execute comedi command' % (PROG_NAME, )
sys.stderr.write(err_msg)
sys.exit(1)
# Read data from buffer - may want to add a timeout here
read_done = False
bytes_total = 2 * config['sample_num'] * nchans
bytes_read = 0
datastr = ''
while not read_done:
try:
buffstr = os.read(fd, bytes_total)
except OSError, err:
if err.args[0] == 4:
continue
raise
datastr += buffstr
bytes_read += len(buffstr)
if config['verbose']:
print '\tread:', bytes_read, 'of', 2 * config[
'sample_num'] * nchans, 'bytes'
if bytes_read == bytes_total:
read_done = True
