def make_cmd_ao(subdev, dt, chlist, nchans, nsamples): dt_ns = int(1.0e6 * dt) cmd = c.comedi_cmd_struct() cmd.subdev = subdev cmd.flags = 0 # c.TRIG_WAKE_EOS cmd.start_src = c.TRIG_INT cmd.start_arg = 0 cmd.scan_begin_src = c.TRIG_TIMER cmd.scan_begin_arg = dt_ns # ns cmd.convert_src = c.TRIG_NOW cmd.convert_arg = 0 #dt_ns/nchans cmd.scan_end_src = c.TRIG_COUNT cmd.scan_end_arg = nchans cmd.stop_src = c.TRIG_NONE # continuous acquisition cmd.stop_arg = 0 cmd.chanlist = chlist cmd.chanlist_len = nchans return cmd
def make_cmd_ao(subdev, dt, chlist, nchans, nsamples): dt_ns = int(1.0e6*dt) cmd = c.comedi_cmd_struct() cmd.subdev = subdev cmd.flags = 0 # c.TRIG_WAKE_EOS cmd.start_src = c.TRIG_INT cmd.start_arg = 0 cmd.scan_begin_src = c.TRIG_TIMER cmd.scan_begin_arg = dt_ns # ns cmd.convert_src = c.TRIG_NOW cmd.convert_arg = 0 #dt_ns/nchans cmd.scan_end_src = c.TRIG_COUNT cmd.scan_end_arg = nchans cmd.stop_src = c.TRIG_NONE # continuous acquisition cmd.stop_arg = 0 cmd.chanlist = chlist cmd.chanlist_len = nchans return cmd
def get_command_stuff(dev, s): buf = "" cmd = c.comedi_cmd_struct() if (c.comedi_get_cmd_src_mask(dev, s, cmd) < 0): print "\tnot supported" else: print "\tstart: %s" % (cmd_src(cmd.start_src, buf)) print "\tscan_begin: %s" % (cmd_src(cmd.scan_begin_src, buf)) print "\tconvert begin: %s" % (cmd_src(cmd.convert_src, buf)) print "\tscan_end: %s" % (cmd_src(cmd.scan_end_src, buf)) print "\tstop: %s" % (cmd_src(cmd.stop_src, buf)) probe_max_1chan(dev, s)
def probe_max_1chan(dev,s): buf="" cmd=c.comedi_cmd_struct() print("\tcommand fast 1chan:") if(c.comedi_get_cmd_generic_timed(dev,s,cmd,1,1)<0): print("\t\tnot supported") else: print("\tstart: %s %d" % (cmd_src(cmd.start_src,buf),cmd.start_arg)) print("\tscan_begin: %s %d" % (cmd_src(cmd.scan_begin_src,buf),cmd.scan_begin_arg)) print("\tconvert begin: %s %d" % (cmd_src(cmd.convert_src,buf),cmd.convert_arg)) print("\tscan_end: %s %d" % (cmd_src(cmd.scan_end_src,buf),cmd.scan_end_arg)) print("\tstop: %s %d" % (cmd_src(cmd.stop_src,buf),cmd.stop_arg))
def get_command_stuff(dev,s): buf = "" cmd = c.comedi_cmd_struct() if (c.comedi_get_cmd_src_mask(dev,s,cmd)<0): print("\tnot supported") else: print("\tstart: %s" % (cmd_src(cmd.start_src,buf))) print("\tscan_begin: %s" % (cmd_src(cmd.scan_begin_src,buf))) print("\tconvert begin: %s" % (cmd_src(cmd.convert_src,buf))) print("\tscan_end: %s" % (cmd_src(cmd.scan_end_src,buf))) print("\tstop: %s" % (cmd_src(cmd.stop_src,buf))) probe_max_1chan(dev,s)
def probe_max_1chan(dev, s): buf = "" cmd = c.comedi_cmd_struct() print "\tcommand fast 1chan:" if (c.comedi_get_cmd_generic_timed(dev, s, cmd, 1, 1) < 0): print "\t\tnot supported" else: print "\tstart: %s %d" % (cmd_src(cmd.start_src, buf), cmd.start_arg) print "\tscan_begin: %s %d" % (cmd_src(cmd.scan_begin_src, buf), cmd.scan_begin_arg) print "\tconvert begin: %s %d" % (cmd_src(cmd.convert_src, buf), cmd.convert_arg) print "\tscan_end: %s %d" % (cmd_src(cmd.scan_end_src, buf), cmd.scan_end_arg) print "\tstop: %s %d" % (cmd_src(cmd.stop_src, buf), cmd.stop_arg)
def prepare_cmd(self,channels,gains,aref,freq): #First create the channel setup nchans = size(channels) channel_config = c.chanlist(nchans) #create a chanlist of length nchans print channel_config print channels for index in range(nchans): channel_config[index]=c.cr_pack(channels[index], gains[index], aref[index]) #Then create the command cmd = c.comedi_cmd_struct() cmd.subdev = self.subdevice cmd.flags = 0 cmd.start_src = c.TRIG_NOW cmd.start_arg = 0 cmd.scan_begin_src = c.TRIG_TIMER cmd.scan_begin_arg = int(1e9/freq) cmd.convert_src = c.TRIG_TIMER cmd.convert_arg = 0 cmd.scan_end_src = c.TRIG_COUNT cmd.scan_end_arg = nchans cmd.stop_src = c.TRIG_NONE cmd.stop_arg = 0 cmd.chanlist = channel_config cmd.chanlist_len = nchans ret = self.test_cmd(cmd) if ret !=0: self.logger.error("Error preparing command") return -1 return cmd
def streamer(device,subdevice,chans,comedi_range,shared_array): ''' read the channels defined in chans, on the device/subdevice, and streams the values in the shared_array. The shared_array has a lock, to avoid reading and writing at the same time and it's process-proof. device: '/dev/comedi0' subdevice : 0=in, 1=out chans : [0,1,2,3,4....] : BE AWARE the reading is done crescendo, no matter the order given here. It means that [0,1,2] and [2,0,1] will both have [0,1,2] as result, but you can ask for [0,1,5]. comedi_range: same size as chans, with the proper range for each chan. If unknown, try [0,0,0,....]. shared_array: same size as chans, must be defined before with multiprocess.Array: shared_array= Array('f', np.arange(len(chans))) ''' dev=c.comedi_open(device) if not dev: raise "Error openning Comedi device" fd = c.comedi_fileno(dev) #get a file-descriptor for use later BUFSZ = 10000 #buffer size freq=8000# acquisition frequency: if too high, set frequency to maximum. nchans = len(chans) #number of channels aref =[c.AREF_GROUND]*nchans mylist = c.chanlist(nchans) #create a chanlist of length nchans maxdata=[0]*(nchans) range_ds=[0]*(nchans) for index in range(nchans): #pack the channel, gain and reference information into the chanlist object mylist[index]=c.cr_pack(chans[index], comedi_range[index], aref[index]) maxdata[index]=c.comedi_get_maxdata(dev,subdevice,chans[index]) range_ds[index]=c.comedi_get_range(dev,subdevice,chans[index],comedi_range[index]) cmd = c.comedi_cmd_struct() period = int(1.0e9/freq) # in nanoseconds ret = c.comedi_get_cmd_generic_timed(dev,subdevice,cmd,nchans,period) if ret: raise "Error comedi_get_cmd_generic failed" cmd.chanlist = mylist # adjust for our particular context cmd.chanlist_len = nchans cmd.scan_end_arg = nchans cmd.stop_arg=0 cmd.stop_src=c.TRIG_NONE t0 = time.time() j=0 ret = c.comedi_command(dev,cmd) if ret !=0: raise "comedi_command failed..." #Lines below are for initializing the format, depending on the comedi-card. data = os.read(fd,BUFSZ) # read buffer and returns binary data data_length=len(data) #print maxdata #print data_length if maxdata[0]<=65536: # case for usb-dux-D n = data_length/2 # 2 bytes per 'H' format = `n`+'H' elif maxdata[0]>65536: #case for usb-dux-sigma n = data_length/4 # 2 bytes per 'H' format = `n`+'I' #print struct.unpack(format,data) # init is over, start acquisition and stream last_t=time.time() try: while True: #t_now=time.time() #while (t_now-last_t)<(1./frequency): #t_now=time.time() ##print t_now-last_t #last_t=t_now data = os.read(fd,BUFSZ) # read buffer and returns binary data #print len(data), data_length if len(data)==data_length: datastr = struct.unpack(format,data) # convert binary data to digital value if len(datastr)==nchans: #if data not corrupted for some reason #shared_array.acquire() for i in range(nchans): shared_array[i]=c.comedi_to_phys((datastr[i]),range_ds[i],maxdata[i]) #print datastr #shared_array.release() #j+=1 #print j #print "Frequency= ",(j/(time.time()-t0)) #print np.transpose(shared_array[:]) except (KeyboardInterrupt): c.comedi_cancel(dev,subdevice) ret = c.comedi_close(dev) if ret !=0: raise "comedi_close failed..."
C.stop_arg = 0 C.chanlist = mylist C.chanlist_len = nchans ## ret = c.comedi_get_buffer_size(dev, subdevice) ## if ret==-1: ## raise "Error fetching comedi buffer size" ## else: ## print "buffer size = ", ret ## ret = c.comedi_get_max_buffer_size(dev, subdevice) ## if ret==-1: ## 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)
def streamer(device, subdevice, chans, comedi_range, shared_array): ''' read the channels defined in chans, on the device/subdevice, and streams the values in the shared_array. The shared_array has a lock, to avoid reading and writing at the same time and it's process-proof. device: '/dev/comedi0' subdevice : 0=in, 1=out chans : [0,1,2,3,4....] : BE AWARE the reading is done crescendo, no matter the order given here. It means that [0,1,2] and [2,0,1] will both have [0,1,2] as result, but you can ask for [0,1,5]. comedi_range: same size as chans, with the proper range for each chan. If unknown, try [0,0,0,....]. shared_array: same size as chans, must be defined before with multiprocess.Array: shared_array= Array('f', np.arange(len(chans))) ''' dev = c.comedi_open(device) if not dev: raise "Error openning Comedi device" fd = c.comedi_fileno(dev) #get a file-descriptor for use later BUFSZ = 10000 #buffer size freq = 8000 # acquisition frequency: if too high, set frequency to maximum. nchans = len(chans) #number of channels aref = [c.AREF_GROUND] * nchans mylist = c.chanlist(nchans) #create a chanlist of length nchans maxdata = [0] * (nchans) range_ds = [0] * (nchans) for index in range( nchans ): #pack the channel, gain and reference information into the chanlist object mylist[index] = c.cr_pack(chans[index], comedi_range[index], aref[index]) maxdata[index] = c.comedi_get_maxdata(dev, subdevice, chans[index]) range_ds[index] = c.comedi_get_range(dev, subdevice, chans[index], comedi_range[index]) cmd = c.comedi_cmd_struct() period = int(1.0e9 / freq) # in nanoseconds ret = c.comedi_get_cmd_generic_timed(dev, subdevice, cmd, nchans, period) if ret: raise "Error comedi_get_cmd_generic failed" cmd.chanlist = mylist # adjust for our particular context cmd.chanlist_len = nchans cmd.scan_end_arg = nchans cmd.stop_arg = 0 cmd.stop_src = c.TRIG_NONE t0 = time.time() j = 0 ret = c.comedi_command(dev, cmd) if ret != 0: raise "comedi_command failed..." #Lines below are for initializing the format, depending on the comedi-card. data = os.read(fd, BUFSZ) # read buffer and returns binary data data_length = len(data) #print maxdata #print data_length if maxdata[0] <= 65536: # case for usb-dux-D n = data_length / 2 # 2 bytes per 'H' format = ` n ` + 'H' elif maxdata[0] > 65536: #case for usb-dux-sigma n = data_length / 4 # 2 bytes per 'H' format = ` n ` + 'I' #print struct.unpack(format,data) # init is over, start acquisition and stream last_t = time.time() try: while True: #t_now=time.time() #while (t_now-last_t)<(1./frequency): #t_now=time.time() ##print t_now-last_t #last_t=t_now data = os.read(fd, BUFSZ) # read buffer and returns binary data #print len(data), data_length if len(data) == data_length: datastr = struct.unpack( format, data) # convert binary data to digital value if len(datastr ) == nchans: #if data not corrupted for some reason #shared_array.acquire() for i in range(nchans): shared_array[i] = c.comedi_to_phys( (datastr[i]), range_ds[i], maxdata[i]) #print datastr #shared_array.release() #j+=1 #print j #print "Frequency= ",(j/(time.time()-t0)) #print np.transpose(shared_array[:]) except (KeyboardInterrupt): c.comedi_cancel(dev, subdevice) ret = c.comedi_close(dev) if ret != 0: raise "comedi_close failed..."
C.chanlist = mylist C.chanlist_len = nchans ## ret = c.comedi_get_buffer_size(dev, subdevice) ## if ret==-1: ## raise Exception("Error fetching comedi buffer size") ## else: ## print("buffer size = ", ret) ## ret = c.comedi_get_max_buffer_size(dev, subdevice) ## if ret==-1: ## raise Exception("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 Exception("comedi_command_test failed")
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