def imagecapture_part(xb, yb, xe, ye, nx, ny, n): dev = comedi.comedi_open("/dev/comedi0") outsubdevice = 1 insubdevice = 0 xchannel = 0 ychannel = 1 inchannel = 0 analogref = comedi.AREF_GROUND arange = 0 image = numpy.zeros((nx,ny), float) for y in range(ny, 0, -1): y = y-1 write_data = int( (float(y)/(ny-1) *(ye-yb) + yb ) * 65535) msg = comedi.comedi_data_write(dev, outsubdevice, ychannel, arange, analogref, write_data) for x in range(0, nx): # print "( " + str(x) + ", " + str(y) + ")" write_data = int( (float(x)/(nx-1) * (xe-xb) + xb ) * 65535) msg = comedi.comedi_data_write(dev, outsubdevice, xchannel, arange, analogref, write_data) pixel = 0.0 for i in range(0, n): result = comedi.comedi_data_read(dev,insubdevice,inchannel,arange,analogref) pixel = pixel + float(result[1]) pixel = pixel/n # print pixel, msg=result[0] image[x][y] = pixel print comedi.comedi_close(dev) return image
def measure(self,arange,aref,num_scans): device = _comedi.comedi_open(comedidev) if not device: raise Exception('error opening Comedi device {}'.format( comedidev)) setup_read_insn = SetupReadInsn( subdevice=subdevice, channel=channel, aref=aref, range=arange, n_scan=num_scans) insns = setup_insns( device, [setup_gtod_insn, setup_read_insn, setup_gtod_insn]) ret = _comedi.comedi_do_insnlist(device, insns) if ret != insns.n_insns: raise Exception('error running instructions ({})'.format(ret)) ret = _comedi.comedi_close(device) if ret != 0: raise Exception('error closing Comedi device') array = _comedi.insn_array.frompointer(insns.insns) t1 = get_time_of_day(array[0]) t2 = get_time_of_day(array[2]) data = _comedi.lsampl_array.frompointer(array[1].data) vals = [] for i in range(array[1].n): vals.append(data[i]) #sig=str((sum(vals) / float(len(vals)))) sig=float(median(vals)) free_insns(insns) ret = _comedi.comedi_close(device) return(sig)
def getimage(nx, ny, n): dev = comedi.comedi_open("/dev/comedi0") outsubdevice = 1 insubdevice = 0 xchannel = 0 ychannel = 1 inchannel = 0 analogref = comedi.AREF_GROUND arange = 0 image = numpy.zeros((nx,ny), float) for y in range(0, ny): write_data = int( (float(y)/(ny-1) ) * 65535) msg = comedi.comedi_data_write(dev, outsubdevice, ychannel, arange, analogref, write_data) for x in range(0, nx): write_data = int( (float(x)/(nx-1) ) * 65535) msg = comedi.comedi_data_write(dev, outsubdevice, xchannel, arange, analogref, write_data) pixel = 0.0 for i in range(0, n): result = comedi.comedi_data_read(dev,insubdevice,inchannel,arange,analogref) pixel = pixel + float(result[1]) pixel = pixel/n # print pixel, msg=result[0] image[x][y] = pixel # print comedi.comedi_close(dev) return pixel
def setx(voltage): dev = comedi.comedi_open("/dev/comedi0") outsubdevice = 1 insubdevice = 0 xchannel = 0 ychannel = 1 inchannel = 0 analogref = comedi.AREF_GROUND arange = 0 write_data = int( (float(voltage)+10)/20*65535) msg = comedi.comedi_data_write(dev, outsubdevice, xchannel, arange, analogref, write_data) comedi.comedi_close(dev)
def diowrite(subdevice, channel, data): dev = comedi.comedi_open("/dev/comedi0") ret1 = comedi.comedi_dio_config(dev, subdevice, channel, comedi.COMEDI_OUTPUT) if ret1 == 1: pass else: print "initialisation failed" ret=comedi.comedi_dio_write(dev, subdevice, channel, data) if ret == 1: pass else: print "setting failed" comedi.comedi_close(dev)
def timedbeamunblank(delay): dev = comedi.comedi_open("/dev/comedi0") subdevice = 2 channel = 0 data = 0 ret1 = comedi.comedi_dio_config(dev, subdevice, channel, comedi.COMEDI_OUTPUT) if ret1 == 1: pass else: print "initialisation failed" start_time = datetime.datetime.now() ret=comedi.comedi_dio_write(dev, subdevice, channel, data) blanked_time = datetime.datetime.now() if ret == 1: pass else: print "setting failed" time.sleep(delay) data = 1 ret=comedi.comedi_dio_write(dev, subdevice, channel, data) end_time = datetime.datetime.now() print "blanked_time =", blanked_time - start_time print "end_time =", end_time - start_time if ret == 1: pass else: print "setting failed" comedi.comedi_close(dev)
if ret<0: raise "error executing comedi_command" while flag: print 'buffer offset', c.comedi_get_buffer_offset(device, subdevice) print ' buffer contents', c.comedi_get_buffer_contents(device, subdevice) front += c.comedi_get_buffer_contents(dev,subdevice) print "front = ", front if front > time_limit: flag = 0 t1 = time.time() # reached "secs" seconds c.comedi_cancel(device, subdevice) c.comedi_poll(device, subdevice) c.comedi_close(dev) break if (front<back): t1 = time.time() # reached "secs" seconds print "front<back" print "ERROR comedi_get_buffer_contents" c.comedi_cancel(device, subdevice) c.comedi_poll(device, subdevice) break if (front==back): print 'sleep' #~ time.sleep(.001) time.sleep(pause) continue
def close(self): c.comedi_cancel(self.device, self.subdevice) ret = c.comedi_close(self.device) if ret != 0: print('Comedi.close failed')
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..."
if (front == back): time.sleep(.01) continue DATA = array.array("H") # reset array to empty ## nbytes = front - back ## chunk_limit = (nbytes / size) * size # count for "size" sized chunks ## remainder = nbytes%size # bytes left after chunk_limit chunks done ## for i in range(0,chunk_limit,size): ## DATA.fromstring(map.read(size)) # read chunks ## for i in range(0,remainder,2): ## DATA.fromstring(map.read(2)) # read remaining bytes map.seek(back % size) for i in range(back, front, 2): DATA.fromstring(map.read(2)) if map.tell() == size: map.seek(0) DATA.tofile(of) # append data to log file ## time.sleep(.01) ret = c.comedi_mark_buffer_read(dev, subdevice, front - back) if ret < 0: raise Exception("error comedi_mark_buffer_read") back = front print("bytes read = ", front) c.comedi_close(dev) if ret < 0: raise Exception("ERROR executing comedi_close") of.flush() of.close() print("Elapsed time = %d seconds" % (t1 - t0))
def close(self): """Close the device.""" c.comedi_cancel(self.device,self.subdevice) ret = c.comedi_close(self.device) if ret !=0: raise Exception('comedi_close failed...') #def _stream(self): #''' #[Deprecated] #Read the channels defined in chans, on the device/subdevice, #and streams the values in the shared_array. #''' #fd = c.comedi_fileno(self.device) # get a file-descriptor #self.BUFSZ = 10000 # buffer size #self.freq=8000 # acquisition frequency #nchans = len(self.channels) # number of channels #self.shared_array= Array('f',np.arange(nchans)) #self.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 informations into the chanlist #mylist[index]=c.cr_pack(self.channels[index], #self.range_num[index], self.aref[index]) #maxdata[index]=c.comedi_get_maxdata(self.device, #self.subdevice,self.channels[index]) #range_ds[index]=c.comedi_get_range(self.device, #self.subdevice,self.channels[index], #self.range_num[index]) #cmd = c.comedi_cmd_struct() #period = int(1.0e9/self.freq) # in nanoseconds #ret = c.comedi_get_cmd_generic_timed(self.device,self.subdevice, #cmd,nchans,period) #if ret: raise Exception("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 #ret = c.comedi_command(self.device,cmd) #if ret !=0: raise Exception("comedi_command failed...") ##Lines below are for initializing the format, depending on the comedi-card. #data = os.read(fd,self.BUFSZ) # read buffer and returns binary data #data_length=len(data) #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' ## init is over, start acquisition and stream ##last_t=time.time() #try: #while True: #data = os.read(fd,self.BUFSZ) # read buffer and returns binary #if len(data)==data_length: #datastr = struct.unpack(format,data) #if len(datastr)==nchans: #if data not corrupted #for i in range(nchans): #self.shared_array[i]=c.comedi_to_phys((datastr[i]), #range_ds[i],maxdata[i]) #except Exception as e: #print "error in comediSensor : ", e #self.close() #raise
def shutdown(aich): ret = c.comedi_close(aich.dev) if ret != 0: comedi_errcheck()
while True: startTime = time.time() ret, rdata = c.comedi_data_read(comediDevice, inputSubdev, channel, theRange, aref) voltage = c.comedi_to_phys(rdata, inputRange, inputMaxdata); #print "Voltage: %f" % voltage x1 = voltage x2 = x1*voltage x3 = x2*voltage x4 = x3*voltage x5 = x4*voltage dist = -14.153*x5+110.18*x4-339.89*x3+538.13*x2-479.23*x1+243.35 #print "Distance: %f" % dist if dist > 50: wdata = outputMaxdata/2 + 1000 else: wdata = outputMaxdata/2 #print 'Writing %d to the motor' % wdata c.comedi_data_write(comediDevice, outputSubdev, channel, theRange, aref, wdata) print time.time() - startTime #time.sleep(1) print "Closing %s" % str(comediDevice) c.comedi_close(comediDevice)
def __del__(self): self.logger.info("Deleting Myself") self.collect_data_stop() self.map.close() c.comedi_close(self.dev)
while (1): #ret = c.comedi_poll(dev,subdevice) #print("poll ret = ", ret) data = os.read(fd,BUFSZ) #print("len(data) = ", len(data)) if len(data)==0: break n = len(data)/2 # 2 bytes per 'H' format = repr(n)+'H' #print("format = ", format) #bytes = struct.calcsize(format) #print("bytes = ", bytes) #nbytes = c.comedi_get_buffer_contents(dev,subdevice) #print("n = ", n, " nbytes = ", nbytes) datastr = datastr + struct.unpack(format,data) t1 = time.time() print("start time : ", t0) print("end time : ", t1) print("time : ", t1 - t0, " seconds") count = 0 while count < len(datastr): for i in range(4): print("%d\t" % datastr[count+i]) print("\n") count = count + 4 ret = c.comedi_close(dev) if ret !=0: raise Exception("comedi_close failed...")
def close(self): s = comedi.comedi_close(self.device) if s < 0: raise InterfaceError('could not close comedi device %s(%s)' % (self.device_name, self.device))
def close(self): """close the output.""" # c.comedi_cancel(self.device,self.subdevice) ret = c.comedi_close(self.device) if ret != 0: raise Exception("comedi_close failed...")
raise Exception('error opening Comedi device {}'.format(args.filename)) setup_read_insn = SetupReadInsn(subdevice=args.subdevice, channel=args.channel, aref=args.aref, range=args.range, n_scan=args.num_scans) insns = setup_insns(device, [setup_gtod_insn, setup_read_insn, setup_gtod_insn]) ret = _comedi.comedi_do_insnlist(device, insns) if ret != insns.n_insns: raise Exception('error running instructions ({})'.format(ret)) ret = _comedi.comedi_close(device) if ret != 0: raise Exception('error closing Comedi device {} ({})'.format( args.filename, ret)) array = _comedi.insn_array.frompointer(insns.insns) t1 = get_time_of_day(array[0]) t2 = get_time_of_day(array[2]) print('initial time: {}'.format(t1)) print('final time: {}'.format(t2)) print('difference: {}'.format(t2 - t1)) print('data:') data = _comedi.lsampl_array.frompointer(array[1].data) for i in range(array[1].n): print(data[i])
print "Cannot load comedi module, please install python-libcomedi" def SetComediDevice(): if os.path.isfile("/proc/comedi"): device = "/dev/comedi0" try: dev = comedi.comedi_open(device) global insubdevice insubdevice = comedi.comedi_get_read_subdevice(dev) # print "subdevice for input = " + str(insubdevice) global outsubdevice outsubdevice = comedi.comedi_get_write_subdevice(dev) # print "subdevice for output = " + str(outsubdevice) return "/dev/comedi0" except: print "cannot open /dev/comedi0, permissions?" else: return "" device = SetComediDevice() print "DAQ device is " + device print "subdevice for input = " + str(insubdevice) print "subdevice for output = " + str(outsubdevice) # dev = comedi.comedi_open(device) comedi.comedi_set_global_oor_behavior(comedi.COMEDI_OOR_NUMBER) comedi.comedi_close(dev)
def main(): # Find comedi analog device number try: with open(COMEDI_PROC_F) as f: #print(f) for line in f.readlines(): m_analog = re.match(PCI_6033E_PATTERN, line) m_digital = re.match(PCI_DIO_32HS_PATTERN, line) if m_analog: print(m_analog.group()) dev_number = m_analog.groups()[0] analog_dev_fname = "/dev/comedi" + dev_number if m_digital: print(m_digital.group()) dev_number = m_digital.groups()[0] digital_dev_fname = "/dev/comedi" + dev_number except IOError: print("Could not find file: %s" % COMEDI_PROC_F) if (f): f.close() if (analog_dev_fname): analog_dev = c.comedi_open(analog_dev_fname) if not(analog_dev): print("Unable to open analog comedi device...") ret = c.comedi_lock(analog_dev, 0) if (ret < 0): print("Could not lock comedi device") ret = c.comedi_get_max_buffer_size(analog_dev, 0) if (ret > 0): print("analog max buffer size: %i" % ret) else: print("Failed to get analog dev max buffer size...") ret = c.comedi_set_max_buffer_size(analog_dev, 0, MAX_BUFFER_SIZE) if (ret > 0): print("analog dev new buffer size: %i" % ret) else: print("Failed to analog dev set max buffer size...") c.comedi_close(analog_dev) if (digital_dev_fname): digital_dev = c.comedi_open(digital_dev_fname) if not(digital_dev): print("Unable to open digital comedi device...") ret = c.comedi_lock(digital_dev, 0) if (ret < 0): print("Could not lock digital comedi device") ret = c.comedi_get_max_buffer_size(digital_dev, 0) if (ret > 0): print("analog max buffer size: %i" % ret) else: print("Failed to get digital dev max buffer size...") ret = c.comedi_set_max_buffer_size(digital_dev, 0, MAX_BUFFER_SIZE) if (ret > 0): print("digital dev new buffer size: %i" % ret) else: print("Failed to digital dev set max buffer size...") c.comedi_close(digital_dev)
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 on_destroy(self, widget): if (self.dev): c.comedi_close(self.dev) print("Comedi device closed...") Gtk.main_quit()
def __del__(self): comedi.comedi_close(self.dev)
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..."
_, zero_phydata = biases[chan_i][range_i] pbs[chan_i][range_i].set_value(phydata - zero_phydata) #['value'] = data #print("[%.3f,%.3f] Raw %d --> voltage %f" %(ranges[rn].min,ranges[rn].max,data,phydata)) # This is the observed reading in each channel channels = [ captured[ch][SELECTED_RANGE][1] for ch, _ in enumerate(CHANNELS) ] #bias = [ biases[ch][SELECTED_RANGE][1] for ch,_ in enumerate(CHANNELS) ] # this is the channel bias, not the G-value-bias (if you know what I mean...) # Now we compute the G0-G5 using the totally awkward combination gs = channels_to_g(channels) # Let's plot the Gs! for i, (greading, gb) in enumerate(zip(gs, gbias)): Glabels[i].set_value(greading - gb) forces = compute_forces(gs, gbias) for (forc, fl) in zip(forces, force_labels): fl.set_value(forc) dumpf.write(" ".join([str(x) for x in channels]) + "\n") dumpf.close() ret = c.comedi_close(dev) if ret < 0: raise Exception("ERROR executing comedi_close")