def readU6Counter(counternumber=0): """ We need to see what state the counter IO is in. If it's already a counter, we just read it. If it is not yet a counter, we instantiate it and return count of 0 Also, this is not safe when other timer and counter inputs are used. For now, this is just one singular counter """ import u6 from iiutilities.datalib import gettimestring device = u6.U6() result = {'readtime': gettimestring()} # When passed no argument, just reads. currentconfig = device.configIO() try: device.getCalibrationData() if currentconfig['Counter0Enabled'] or currentconfig[ 'NumberTimersEnabled'] != 1: device.configIO(EnableCounter0=True, NumberTimersEnabled=1) device.getFeedback(u6.Timer0Config(TimerMode=6, Value=1)) result['value'] = device.getFeedback(u6.Timer0())[0] except: pass # Error handling .... device.close() return result
def loadDevice(self, deviceType): """ Name: loadDevice(deviceType) Desc: loads the first device of device type """ self.deviceType = deviceType # Determine which device to use if self.deviceType == LJTickDAC.U3: self.device = u3.U3() elif self.deviceType == LJTickDAC.U6: self.device = u6.U6() else: self.device = ue9.UE9() # Display serial number self.serialDisplay.config(text=self.device.serialNumber) # Configure pins if U3 if self.deviceType == LJTickDAC.U3: self.device.configIO( FIOAnalog=15, TimerCounterPinOffset=8) # Configures FIO0-2 as analog # Get the calibration constants self.getCalConstants()
def __init__(self): self.device = u6.U6() print self.device.configU6() #for the labjack self.numChannels = 12 self.firstChannel = 2 self.resolutionIndex = 4 self.gainIndex = 0 self.settlingFactor = 0 self.differential = False self.latestAinValues = np.array([0]*self.numChannels, dtype='float') self.lastForceMoments = np.array([0]*self.numChannels, dtype='float') self.latestForceMoments = np.array([0]*self.numChannels, dtype='float') self.zero = np.array([0]*self.numChannels, dtype='float') self.lastTime = 0 self.latestTime = 0 self.lastLeftOn = False self.latestLeftOn = False self.lastLeftCOP = [0, 0] self.latestLeftCOP = [0, 0] self.lastRightOn = False self.latestRightOn = False self.lastRightCOP = [0, 0] self.latestRightCOP = [0, 0] FIOEIOAnalog = ( 2 ** self.numChannels ) - 1; fios = FIOEIOAnalog & (0xFF) eios = FIOEIOAnalog/256 self.device.getFeedback(u6.PortDirWrite(Direction = [0, 0, 0], WriteMask = [0, 0, 15])) self.feedbackArguments = [] self.feedbackArguments.append(u6.DAC0_8(Value = 125)) self.feedbackArguments.append(u6.PortStateRead()) for i in range(self.firstChannel, self.numChannels+self.firstChannel): self.feedbackArguments.append( u6.AIN24(i, self.resolutionIndex, self.gainIndex, self.settlingFactor, self.differential) ) self.task = viztask.schedule(self.__update) self.going = True self.history = [] self.recording = False #magic numbers to turn volts into Newtons and Newton.meters #left is stored in first 6 (x,y,z,mx,my,mz) and right in second 6 self.M = np.array([[0, -2.309900 , 0.000000 , 1.308000 , 0.000000 , 2.306800 , 0.000000 , -495.780000 , 0.000000 , -494.040000 , 0.000000 , -2.034400],\ [0, 6.308900 , 0.000000 , 5.913600 , 0.000000 , 11.633000 , 0.000000 , -2.295700 , 0.000000 , -13.079000 , 0.000000 , 499.990000],\ [0, -491.360000 , 0.000000 , -488.510000 , 0.000000 , -488.270000 , 0.000000 , 5.064000 , 0.000000 , 6.732400 , 0.000000 , 0.391790],\ [0, 48.162000 , 0.000000 , -298.930000 , 0.000000 , 299.410000 , 0.000000 , -1.565600 , 0.000000 , 4.956800 , 0.000000 , 54.786000],\ [0, -254.760000 , 0.000000 , -26.647000 , 0.000000 , -25.153000 , 0.000000 , 42.462000 , 0.000000 , 42.087000 , 0.000000 , 1.601900],\ [0, -7.032800 , 0.000000 , 1.345700 , 0.000000 , -1.140100 , 0.000000 , -243.640000 , 0.000000 , 354.550000 , 0.000000 , -4.020500],\ [-2.688400 , 0.000000 , -0.083334 , 0.000000 , 1.258500 , 0.000000 , 491.220000 , 0.000000 , -495.750000 , 0.000000 , -6.723600 , 0],\ [-7.642900 , 0.000000 , -5.959700 , 0.000000 , -3.659100 , 0.000000 , 15.847000 , 0.000000 , -12.401000 , 0.000000 , 507.580000 , 0],\ [-490.840000 , 0.000000 , -490.690000 , 0.000000 , -492.520000 , 0.000000 , -6.428000 , 0.000000 , 3.723600 , 0.000000 , 4.807000 , 0],\ [300.830000 , 0.000000 , -300.260000 , 0.000000 , 48.265000 , 0.000000 , -5.152500 , 0.000000 , -1.434500 , 0.000000 , 49.278000 , 0],\ [26.955000 , 0.000000 , 27.005000 , 0.000000 , 253.680000 , 0.000000 , -40.116000 , 0.000000 , 41.703000 , 0.000000 , -1.501700 , 0],\ [-1.380200 , 0.000000 , -2.450800 , 0.000000 , -1.349500 , 0.000000 , -348.250000 , 0.000000 , -245.680000 , 0.000000 , 10.366000 , 0]],\ dtype='float')
def __init__(self): self.devicename = 'LJ' self.lj = u6.U6() self.dacPin = LabJack.DAC_PIN_DEFAULT self.sclPin = self.dacPin self.sdaPin = self.sclPin + 1 self.getCalConstants()
def read_volts(ch, dmmtype): global dmm v = [] if dmmtype == "u6": if diff: di = 2 iend = int(ch) * 2 else: di = 1 iend = int(ch) for i in range(0, iend, di): try: v.append(dmm.getAIN(i, differential=diff)) except: print("Got zero packet") dmm.close() time.sleep(0.5) dmm = u6.U6() dmm.getCalibrationData() v.append(np.nan) elif dmmtype == "agil": v = float(dmm.ask(":MEAS:VOLT:DC?")) elif dmmtype == "test": for i in range(0, int(ch)): v.append(np.random.randn()) else: raise ValueError("Acquisition Type not recognized.") return v
def __init__( self, parameters ): # number of packets to be read self.max_packets = parameters['max_packets'] # At high frequencies ( >5 kHz), the number of samples will be max_packets # times 48 (packets per request) times 25 (samples per packet) self.num_samples = self.max_packets*48*25 # initialize LabJack U6 device self.d = u6.U6() # For applying the proper calibration to readings. self.d.getCalibrationData() # number of analog channels self.num_analog_channels = parameters['num_analog_channels'] # configure stream print "configuring U6 stream" self.d.streamConfig( NumChannels = self.num_analog_channels, ChannelNumbers = range(self.num_analog_channels), ChannelOptions = [0]*self.num_analog_channels, SettlingFactor = 1, ResolutionIndex = 1, SampleFrequency = 50000/self.num_analog_channels ) # get stream reader self.sdr = StreamDataReader(self.d,max_packets=self.max_packets) self.sdrThread = threading.Thread(target = self.sdr.readStreamData) # output list self.out = [] self.out_arr = None
def start(self): """ Name:MainWindow.start() Desc:Starts reading values from EI1050 probe """ try: # Get device selection if len(LabJackPython.listAll(3)) > 0: self.device = u3.U3() elif len(LabJackPython.listAll(6)) > 0: self.device = u6.U6() else: self.device = ue9.UE9() self.serialDisplay.config(text=self.device.serialNumber) # Create and start the thread self.thread = ei1050.EI1050Reader(self.device, self.targetQueue) # Start scheduleing self.window.after(1000, self.updateLabels) self.thread.start() # Change button self.startButton.config(text="Stop", command=self.stop) except: showErrorWindow(sys.exc_info()[0], sys.exc_info()[1])
def acquireStack(cam, nFrames, downscaleTuple, animal, outdir): """ Get an image stack from the camera. Args: cam: (TIS_CAM) initialized camera object nFrames: (int) number of frames to acquire sendCounter (bool) whether or not to send strobe signal downscaleTuple: (tuple) downscale factor in (z, x, y), e.g. (1, 2, 2) for 2x downscale animal: (str) animal ID, used for output naming outdir: (str) path to output directory Returns: stack: (np.ndarray) image stack in (z, x, y) """ # setup the labjack dioPortNum = 0 # FIO0 u6Obj = u6.U6() u6Obj.configU6() u6Obj.configIO() u6Obj.setDOState(dioPortNum, state=0) stack = [] cam.StartLive(1) # Not using 191001: strobe code below. # if sendCounter: # _set_and_check(cam.SetPropertyValue, 'GPIO', 'GP Out', 1) # _set_and_check(cam.PropertyOnePush, 'GPIO', 'Write') t_start = time.time() for iF in np.arange(nFrames): pulseLengthTicks = int(1000/64) u6Obj.getFeedback(u6.BitDirWrite(dioPortNum, 1), u6.BitStateWrite(dioPortNum, State=1), u6.WaitShort(pulseLengthTicks), u6.BitStateWrite(dioPortNum, State=0)) cam.SnapImage() im = cam.GetImage() # appears to have three identical(?) frames im = np.mean(im, axis=2).astype('int16') stack.append(im) # averaging to one frame # Not using 191001: strobe code below. # if sendCounter: # _set_and_check(cam.SetPropertyValue, 'GPIO', 'GP Out', 0) # _set_and_check(cam.PropertyOnePush, 'GPIO', 'Write') cam.StopLive() print('Done. Downsizing and saving.') stack = np.r_[stack] stack = transform.downscale_local_mean(stack, downscaleTuple) stack = stack.astype('int16') timeStr = time.strftime("_%y%m%d_%H-%M-%S", time.localtime(t_start)) outfile = os.path.join(outdir, '{}{}.tif'.format(animal, timeStr)) tfl.imsave(outfile, stack) nFrames = stack.shape[0] print('Saved {} frames to {}'.format(nFrames, outfile)) return stack
def connect(self): """ Connect to U6 LabJack. """ try: self.sensor = u6.U6() except TypeError: print("Can't find LabJack. Is it connected?")
def connect(self): self._device = u6.U6() self._device.getCalibrationData() # Set up a frequency source for testing. self._device.configIO(NumberTimersEnabled=1) # 1MHz / 250 = 4 kHz self._device.configTimerClock(3, 250) # 4KHz / 2 * 16 = 125 Hz self._device.getFeedback(u6.Timer0Config(7, 16))
def connect(self): iscompleted = False nbattempts = 0 while not(iscompleted) and nbattempts<1000:#while iscompleted is false and nb<1000 will be doing this constantly try: nbattempts = nbattempts +1 #print ('Attempt nb ' + str(nbattempts)) self.jack = u6.U6() iscompleted = True except: print('Pb with labjack initialisation nb '+ str(nbattempts)) time.sleep(0.01) if not(iscompleted): #if iscompleted equals false which would give true he raise IOError('Labjack could not connect') # the FIO0-FIO7 inputs are flexible, meaning they can be analog or digital, so ensure # they are all digital by sending a zero for the FIO Analog parameter # self.jack.configIO(FIOAnalog = 0) # now set all the channels to output, since each digital IO channel supports input and output for channel in BIOPAC_CHANNELS: #self.jack.getFeedback(u6.BitDirWrite(channel,DIGITAL_CHANNEL_DIRECTION_OUTPUT)) self.sendMsg(u6.BitDirWrite(channel,DIGITAL_CHANNEL_DIRECTION_OUTPUT)) for channel in EYETRACKER_CHANNELS: #self.jack.getFeedback(u6.BitDirWrite(channel,DIGITAL_CHANNEL_DIRECTION_OUTPUT)) self.sendMsg(u6.BitDirWrite(channel,DIGITAL_CHANNEL_DIRECTION_OUTPUT)) for channel in DIGITIMER_CHANNELS: #self.jack.getFeedback(u6.BitDirWrite(channel, DIGITAL_CHANNEL_DIRECTION_OUTPUT)) self.sendMsg(u6.BitDirWrite(channel, DIGITAL_CHANNEL_DIRECTION_OUTPUT))
def __init__(self): # A buffer for incoming data. Use deque for fast writes. self.buffer = deque() # Integration time in seconds self.t_integrate = 1 self._device = u6.U6() self._device.getCalibrationData() self._barrier = threading.Barrier(2) self.data_ready = threading.Event()
def check_pressure(): fh = open('pressure_data.txt', 'a+') d = u6.U6() AIN_channel = 6 #set MOT AIN channel here AIN_voltage = d.getAIN(AIN_channel) a = float(int(AIN_voltage)) - 11.0 b = (AIN_voltage - float(int(AIN_voltage)) + 0.1) / 0.11 current_mot_pressure = round(b, 3) * 10**a e = u6.U6() AIN_channel_2 = 10 #set backing AIN channel here AIN_voltage = e.getAIN(AIN_channel_2) current_backing_pressure = round(10**(float(AIN_voltage) - 5.0) * 1000.0, 1) fh.write( str(current_backing_pressure) + " , " + str(current_mot_pressure) + " , " + (time.strftime("%H:%M:%S")) + " , " + (time.strftime("%d/%m/%Y")) + " \n") fh.close() print("backing pressure: " + str(current_backing_pressure) + " mTorr " + "MOT pressure: " + str(current_mot_pressure) + " Torr") return current_mot_pressure, current_backing_pressure
def init_device(): d = u6.U6() # ## For applying the proper calibration to readings. d.getCalibrationData() # logging.info("configuring U6 stream") d.streamConfig(NumChannels=6, ChannelNumbers=[0, 2, 4, 6, 8, 10], ChannelOptions=[128, 128, 128, 128, 128, 128], SettlingFactor=1, ResolutionIndex=1, SampleFrequency=1000) return d
def connectDevice(self): try: if self.runningFlag: pass else: self.labJackU6 = u6.U6() self.labJackU6.getCalibrationData() self.checkConnectionThread() self.supportClass.statusBar.showMessage( "Connection State: Connected") self.runningFlag = True self.supportClass.runningFlag = True return True except Exception as e: print(e) return False
def __init__(self): super().__init__() self.grid_rowconfigure(0, w=1) self.grid_columnconfigure(0, w=1) self.grid_columnconfigure(1, w=1) self.Dict = { 'AIN0' : 'Failure', 'AIN1' : 'Low Speed', 'AIN2' : 'Frequency', 'AIN3' : 'Supply Current', 'AIN4' : 'Driving Frequency', 'FIO3' : 'Error Reset', 'FIO4' : 'On/Off', 'FIO5' : 'Low Speed Activate', 'FIO6' : 'Enable Override', 'DAC0' : 'Direction', 'FIO0' : 'Frequency Driver', 'FIO1' : 'Timer Stop', 'AIN5' : 'Inner Limit Switch', 'AIN6' : 'Outer Limit Switch', } s = ttk.Style() s.configure('.', font=('Times', 18)) s.configure('Header.TLabel', font=('Times', 24)) self.DevFlag = False try: self.LJ = u6.U6() self.LJ.getCalibrationData() for i in range(20): self.LJ.getFeedback(u6.BitDirWrite(i, 0)) # output self.LJ.configTimerClock(TimerClockBase=3, TimerClockDivisor=2) self.LJ.configIO(NumberTimersEnabled=2) except: self.DevFlag = True print('Dev') self.turbo = TurboController(self) self.turbo.grid(row=0, column=0, sticky='news') self.stepper = StepperController(self) self.stepper.grid(row=0, column=1, sticky='news')
def readU6Analog(positiveChannel, resolutionIndex=0, gainIndex=0, settlingFactor=0, differential=False): """ Name: U6.getAIN(positiveChannel, resolutionIndex = 0, gainIndex = 0, settlingFactor = 0, differential = False) Args: positiveChannel, the positive channel to read from resolutionIndex, the resolution index. 0 = default, 1-8 = high-speed ADC, 9-12 = high-res ADC (U6-Pro only). gainIndex, the gain index. 0=x1, 1=x10, 2=x100, 3=x1000, 15=autorange. settlingFactor, the settling factor. 0=Auto, 1=20us, 2=50us, 3=100us, 4=200us, 5=500us, 6=1ms, 7=2ms, 8=5ms, 9=10ms. differential, set to True for differential reading. Negative channel is positiveChannel+1. Desc: Reads an AIN and applies the calibration constants to it. >>> myU6.getAIN(14) 299.87723471224308 strRanges = ["+/- 10", "+/- 1", "+/- 0.1", "+/- 0.01"] """ from iiutilities.datalib import gettimestring import u6 result = {} device = u6.U6() result['readtime'] = gettimestring() try: device.getCalibrationData() result['value'] = device.getAIN(positiveChannel, resolutionIndex, gainIndex, settlingFactor, differential) except: #handle stuff ... pass device.close() return result
def record_pressure_trace(time_interval=600): """ """ import time d = u6.U6() d.configU6() pkr = PKR251(d) pressure = [] t = [] t0 = time.time() for i in range(time_interval): pressure.append(pkr.get_pressure('torr')) t.append(time.time() - t0) time.sleep(1) print('time: {0:.2f}s; pressure: {1:2e}torr'.format( t[-1], pressure[-1])) return t, pressure
def __init__(self): ''' Initializing the a QuenchManager involves reading the hardware data for the quenches from quench.csv, and opening the relevant LabJacks. This will not work for more than one instance of a QuenchManager since LabJacks cannot be opened from more than one Python kernel at a time. ''' # Open quench information file. self.quench_info = quench_info num_quenches = len(self.quench_info.index) # Create new columns specifically for this instance of a QuenchManager. self.quench_info["Is Open"] = [False for i in range(num_quenches)] self.quench_info["Is On"] = [False for i in range(num_quenches)] self.quench_info["Handle"] = [None for i in range(num_quenches)] # Open the relevant LabJacks. try: self.quench_u3 = u3.U3(autoOpen=False) self.quench_u3.open(serial=320044466) self.quench_u3.configIO(FIOAnalog=255) except LabJackException as err: print("U3 error:") print(err.__str__) raise err finally: print("U3 opened") try: self.quench_u6 = u6.U6(autoOpen=False) self.quench_u6.open(serial=360007343) except LabJackException as err: print("U6 error:") print(err.__str__) raise err finally: print("U6 opened")
def readU6(registers): import u6 from iiutilities.datalib import gettimestring device = u6.U6() resultslist = [] for register in registers: try: value = device.readRegister(register) status = 0 except: value = '' status = 1 resultslist.append({ 'register': register, 'value': value, 'status': status, 'time': gettimestring() }) print(resultslist) return resultslist
""" The default SPI settings for a U6 are: AutoCS = True, DisableDirConfig = False, SPIMode = 'A', SPIClockFactor = 0, CSPinNum = 0 (FIO0), CLKPinNum = 1 (FIO1), MISOPinNum = 2 (FIO2), MOSIPinNum = 3 (FIO3) Note the CSPinNum, CLKPinNum, MISOPinNum, and MOSIPinNum pin numbers and make your connections accordingly. """ from __future__ import print_function import os import time import u6 d = u6.U6() #Open first found U6 over USB def convert(inByte2, inByte3): combined = inByte2 * 256 + inByte3 return combined while (True): d.setDOState(4, 0) results = d.spi([0x00, 0]) inByte1 = results['SPIBytes'][0] inByte2 = results['SPIBytes'][1] results = d.spi([0x00, 0]) inByte3 = results['SPIBytes'][0]
def connect(self): self.d = u6.U6() self.d.getCalibrationData()
def init_comm(): global chan_d chan_d['port'] = u6.U6()
if failed==False: #set up some options that should not change often dummy=indi.set_and_send_text("SX CCD SXVR-H694","UPLOAD_MODE","UPLOAD_CLIENT","Off") dummy=indi.set_and_send_text("SX CCD SXVR-H694","UPLOAD_MODE","UPLOAD_BOTH","Off") dummy=indi.set_and_send_text("SX CCD SXVR-H694","UPLOAD_MODE","UPLOAD_LOCAL","On") dummy=indi.set_and_send_text("SX CCD SXVR-H694","CCD_COOLER","COOLER_ON","On") dummy=indi.set_and_send_text("SX CCD SXVR-H694","CCD_COOLER","COOLER_OFF","Off") # Default binning is 1x1. Not need to set this as it is a CCD default. # dummy=indi.set_and_send_float("SX CCD SXVR-H694","CCD_BINNING","VER_BIN",2) if not os.path.exists('./images/'): dummy=subprocess.call('mkdir ./images', shell=True) dummy=indi.set_and_send_text("SX CCD SXVR-H694","UPLOAD_SETTINGS","UPLOAD_DIR","images") dummy=indi.set_and_send_text("SX CCD SXVR-H694","UPLOAD_SETTINGS","UPLOAD_PREFIX","TEMPIMAGE") try: LJ=u6.U6() #Need to set up fancy DAC here for the temperature control #LJ.configIO(NumberOfTimersEnabled = 2, EnableCounter0 = 1, TimerCounterPinOffset=8) #LJ.getFeedback(u3.Timer0Config(8), u3.Timer1Config(8)) #Sets up the dome tracking wheel #Start off with no current: LJ.getFeedback(u6.BitStateWrite(1,0)) #H-Bridge bit 1 LJ.getFeedback(u6.BitStateWrite(2,0)) #H-Bridge bit 2 LJ.getFeedback(u6.BitStateWrite(3,0)) #Back-LED Off except Exception: print 'Unable to connect to the labjack.' class Subaru(): """As this server class controls several pieces of hardware at once, d defaults for this class are in blocks, in the order below...
from numpy import * import u6 h = u6.U6() while True: tF0 = h.getFeedback(u6.PortDirRead()) tF1 = h.getFeedback(u6.PortStateRead()) print tF0, tF1
try: import Queue except ImportError: # Python 3 import queue as Queue import u6 # MAX_REQUESTS is the number of packets to be read. MAX_REQUESTS = 2500 ################################################################################ ## U6 ## Uncomment these lines to stream from a U6 ################################################################################ ## At high frequencies ( >5 kHz), the number of samples will be MAX_REQUESTS times 48 (packets per request) times 25 (samples per packet) d = u6.U6() # ## For applying the proper calibration to readings. d.getCalibrationData() # print "configuring U6 stream" d.streamConfig(NumChannels=1, ChannelNumbers=[0], ChannelOptions=[0], SettlingFactor=1, ResolutionIndex=1, SampleFrequency=50000) class StreamDataReader(object): def __init__(self, device):
@author: paulnakroshis """ # streamU3.py # Peter N. Saeta, 2011 July 2 # Using the LabJack U3, sample four voltages at a fixed sampling rate # and log the results to a text file. This file can then be used by # Igor to manage further analysis import u6 from time import sleep from math import * # Prepare the u3 interface for streaming d = u6.U6( ) # initialize the interface; assumes a single U3 is plugged in to a USB port d.configU6() # set default configuration #d.configIO( FIOAnalog = 1 ) # ask for analog inputs # The following requests 4 analog input channels to be streamed, # with the positive terminals being 0-3 and the negative terminals # all set to 31. The sampling frequency is 5000 samples (of each channel) # per second. The Resolution parameter sets the effective quality of the # samples. See http://labjack.com/support/u3/users-guide/3.2 d.streamConfig(NumChannels=4, PChannels=[0, 1, 2, 3], NChannels=[31, 31, 31, 31], Resolution=3, SampleFrequency=5000) d.packetsPerRequest = 100 # you can adjust this value to get more or less data
def init_labjack(): #initialize the U6 and return the handle d = u6.U6() d.getCalibrationData() return d
#! /usr/bin/python import u6 import pylab import numpy as np import time, datetime, os today = datetime.date.today() # get time string for folder name todaystr = today.isoformat() d = u6.U6() # open LabJack U6 d.getCalibrationData() # get calibration info for U6 # turn off device first DAC0_value = d.voltageToDACBits(0, dacNumber = 0, is16Bits = False) d.getFeedback(u6.DAC0_8(DAC0_value)) device_type = raw_input('Are you calibrating led or lasergreen or laserblue or laserblueC? ') fiber_type = raw_input('What is your fiber diameter(nm)? ') # Set DAC0 to 2V and get analog reading from AIN0 to calculate scale if device_type == "led": startV = 0.07 stopV = 5 nVPts = 81 DAC0_value = d.voltageToDACBits(1.4, dacNumber = 0, is16Bits = False) elif device_type == "lasergreen": startV = 1.5 stopV = 3 nVPts = 19
def __init__(self, task_manager): self.task_manager = task_manager #class that controls all elements and I/O self.device = u6.U6() self.device.configU6()