def DigitalOutputOnePin(Pin=None, LowHigh=None): ''' Desc: Sets on pin (FIO4-7) to be digital output. In such a case either high (3.4 V) or low (0 V) should be specified. !!! Remember not to use this function for pin AIN0-3!!! Ex: >>> LJU3HV.DigitalInputOutputOnePin(Pin=5, LowHigh='H') Pin 5 was set to high digital output(3.4 V) ''' if Pin is not None: d.configIO(FIOAnalog=(255 - 2**Pin)) d.getFeedback(u3.BitDirWrite(Pin, 1)) if LowHigh == 'H': d.getFeedback(u3.BitStateWrite(Pin, 1)) elif LowHigh == 'L': d.getFeedback(u3.BitStateWrite(Pin, 0)) else: print('For digital output set if it is about to be high or low') else: print 'No pin specified'
def initialize(self, *args, **kw): self.scl_pin = self.dac_pin + 4 self.sda_pin = self.scl_pin + 1 self._device.getFeedback( u3.BitStateWrite(4, 0) ) # write both sleep lines low to prevent stepper from moving on load self._device.getFeedback( u3.BitStateWrite(5, 0) ) # write both sleep lines low to prevent stepper from moving on load self._device.configIO(FIOAnalog=15, NumberOfTimersEnabled=2, TimerCounterPinOffset=8) self._device.configTimerClock( TimerClockBase=3, TimerClockDivisor=50) # 3 = 1 Mhz; 50 ==> 1/50 = 20 kHz self._device.getFeedback( u3.Timer0Config(TimerMode=7, Value=100) ) # FreqOut mode; Value 20 gives (20 kHz)/(2*100) = 100 Hz self._device.getFeedback( u3.Timer1Config(TimerMode=7, Value=100) ) # FreqOut mode; Value 20 gives (20 kHz)/(2*100) = 100 Hz print('device SN is ', self._device.serialNumber) data = self._i2c(0x50, [64], NumI2CBytesToReceive=36) response = data['I2CBytes'] print(response[0:8]) self.a_slope = self.to_double(response[0:8]) self.a_offset = self.to_double(response[8:16]) self.b_slope = self.to_double(response[16:24]) self.b_offset = self.to_double(response[24:32]) self.test_connection()
def VMOpenValve(self, valve): print("Open: " + str(valve),end="") #Pass Valve Number to be addressed. self.ValveAddress(valve) #Pulse In2 for addressed Valve self.d.getFeedback(u3.BitStateWrite(IONumber=10, State = 1)) #50ms hold time.sleep(0.05) #Pulse In1 to reset Valve self.d.getFeedback(u3.BitStateWrite(IONumber=10, State = 0))
def pulse_bit(self, bit): """ This drops the designated bit to state 0 for half a second To ensure that it is seen as a negative pulse, the bit is set high for one second if it was not already high. """ if self.getFeedback(u3.BitStateRead(IONumber=bit)) == 0: self.getFeedback(u3.BitStateWrite(IONumber=bit, State=1)) time.sleep(1) self.getFeedback(u3.BitStateWrite(IONumber=bit, State=0)) time.sleep(0.5) self.getFeedback(u3.BitStateWrite(IONumber=bit, State=1))
def __init__(self): self.d = u3.U3() self.d.getCalibrationData() FIOAnalogChans = 0 EIOAnalogChans = 0 fios = FIOAnalogChans & 0xFF eios = EIOAnalogChans & 0xFF self.d.configIO(FIOAnalog=fios, EIOAnalog=eios) self.d.getFeedback(u3.PortDirWrite(Direction=[0, 0, 0], WriteMask=[0, 0, 15])) # print("Before Feedback") #Pin 0 (FIO0) Hold low to select Valves 0-15 on the Valve Master 2000 Board self.d.getFeedback(u3.BitStateWrite(IONumber=8, State = 0)) #Pin 1 (FIO1) Hold low to enable output self.d.getFeedback(u3.BitStateWrite(IONumber=9, State = 0)) #Pin 2 (FIO2) Set Low to disable H-Bridge Drivers Port A (Open Valve) self.d.getFeedback(u3.BitStateWrite(IONumber=10, State = 0)) #Pin 3 (FIO3) Set Low to disable H-Bridge Drivers Port B (Close Valve) self.d.getFeedback(u3.BitStateWrite(IONumber=11, State = 0)) self.d.getFeedback(u3.BitStateWrite(IONumber=12, State = 0)) self.d.getFeedback(u3.BitStateWrite(IONumber=13, State = 0)) self.d.getFeedback(u3.BitStateWrite(IONumber=14, State = 0)) self.d.getFeedback(u3.BitStateWrite(IONumber=15, State = 0))
def setDigIOState(self, io_channel, state): '''Set the state of a Digital IO Channel ''' if state == 'high': self.safeLJOpen() self.lj.getFeedback(u3.BitStateWrite(io_channel, 1)) # Set IO channel to high self.lj.close() elif state == 'low': self.safeLJOpen() self.lj.getFeedback(u3.BitStateWrite(io_channel, 0)) # Set IO channel to low self.lj.close() else: print 'Error: Direction not valid'
def func(): dev = self._device if direction == 'forward': dev.getFeedback(u3.BitStateWrite(a_id, 0)) else: dev.getFeedback(u3.BitStateWrite(a_id, 1)) # st = time.time() dev.getFeedback(u3.BitStateWrite(b_id, 1)) time.sleep(runtime) self.info('adjk;fdsajf ', runtime) # while time.time() - st < runtime: # time.sleep(1) dev.getFeedback(u3.BitStateWrite(b_id, 0))
def __init__(self): self.d = u3.U3() # Configure all ports as digital self.d.configIO(0) # Configure the output port as output, input as input self.d.getFeedback([ u3.BitDirWrite(self.INPUT_PORT, 0), u3.BitDirWrite(self.OUTPUT_PORT, 1) ]) # Store commands, for easy reference self.out_cmd = [ u3.BitStateWrite(self.OUTPUT_PORT, 1), u3.BitStateWrite(self.OUTPUT_PORT, 0) ] self.in_cmd = u3.BitStateRead(self.INPUT_PORT)
def _walk(self, direction): """changes the controller movement direction controller movement direction is changed by setting the bit pattern at corresponding U3 digital output pins. This function only changes movement direction. To generate pulses (e.g. movement-direction-change sequence of STOP-RIGHT-STOP) you have to use the function ``self.walk`` For the specifics of how to compose command lists and send them to the Labjack U3 (as it is implemented here) check out the Labjack documentation. Parameter: ---------- direction | str specifies the movement direction. """ self._check_motor_direction(direction) bit_pattern = self.mot_dir[direction] command_lst = [] for bit, state in bit_pattern.items(): io_num = self.pin_dct[bit] command_lst.append(u3.BitStateWrite(io_num, state)) self.d.getFeedback(*command_lst) return
def writeBitState(self, pinNum, state): """ Name: EI1050.writeBitState(pinNum, state) Desc: Device independent way to write bit state """ if self.deviceType == EI1050.U3: self.device.getFeedback(u3.BitStateWrite(pinNum,state)) elif self.deviceType == EI1050.U6: self.device.getFeedback(u6.BitStateWrite(pinNum,state)) elif self.deviceType == EI1050.UE9: self.device.singleIO(1, pinNum, Dir=1, State=state)
def ValveAddress(self, valve): zero = 0 #Convert incoming valve integer (0-8) to a binary string result = [int(digit) for digit in bin(valve)[2:]] #Make sure string is 4 characters in length while(len(result)!=4): result = [zero] + result #print binary address #print(result) #Write each character (0 or 1) in string 'result' to state of each bit address for i in range(len(result)): self.d.getFeedback(u3.BitStateWrite(IONumber = 15-i, State = int(result[i])))
def DigitalOutputOneProperty(ConfigList=[], Property=None, LowHigh=None): ''' Desc: Sets on pin (FIO4-7) to be digital output. In such a case either high (3.4 V) or low (0 V) should be specified. !!! Remember not to use this function for AIN0-3!!! Ex: >>> LJU3HV.DigitalInputOutputOnePin(ConfigList=LJU3HV.ReadConfiguration(), Property='AirTemp', LowHigh='H') """the following element of LJU3HV.ReadConfiguration() is considered: ['FIO5', 'Mode:AI', 'NegChan:SE', 'LongSettle:F', 'QuickSample:F', 'Property:AirTemp', 'Unit:C', 'P_min:0', 'P_max:10', 'V_min[V]:0', 'V_max[V]:2.44', 'Dig:L', '|\n']""" Pin 5 was set to high digital output(3.4 V) notwithstanding that according to the configuration file this pin was about to be analog input. However the only relevant information taken from the aforementioned file is the name of the property. ''' Checker = None for b in range(4, 8): PropertyList = ConfigList[b][5].split(':') if Property == PropertyList[1]: d.configIO(FIOAnalog=(255 - 2**b)) Checker = PropertyList[1] d.getFeedback(u3.BitDirWrite(b, 1)) if LowHigh == 'H': d.getFeedback(u3.BitStateWrite(b, 1)) elif LowHigh == 'L': d.getFeedback(u3.BitStateWrite(b, 0)) else: print( 'For digital output set if it is about to be high or low') if Checker is None: print 'No property chosen at all'
def multicycle( device, fio1, fio2, rate, duration ): sleepTime = 1.0/rate; #device.setFIOState(fio,0); device.getFeedback(u3.BitStateWrite(fio1, 0),u3.BitStateWrite(fio2, 0),u3.BitStateWrite(6, 0)) start = time.time() current = start emgSig = 1 DAC0_VALUE = d.voltageToDACBits(3.5, dacNumber = 0, is16Bits = False) d.getFeedback(u3.DAC0_8(DAC0_VALUE)) # Set DAC0 to 1.5 V while( (current - start) < duration): print current - start #device.setFIOState(fio,1); device.getFeedback(u3.BitStateWrite(fio1, 1),u3.BitStateWrite(fio2, 1),u3.BitStateWrite(6, 1) ) emgSig = 0 sleep( sleepTime ); #device.setFIOState(fio,0); device.getFeedback(u3.BitStateWrite(fio1, 0),u3.BitStateWrite(fio2, 0),u3.BitStateWrite(6, 0) ) current = time.time() DAC0_VALUE = d.voltageToDACBits(0, dacNumber = 0, is16Bits = False) d.getFeedback(u3.DAC0_8(DAC0_VALUE)) # Set DAC0 to 1.5 V
def send_bit(self, bit, value): """ """ self.logger.debug("send_bit: Setting EIO bit %d to %d", bit, value) try: error = self.LJ.getFeedback( u3.BitStateWrite(IONumber = WBDCsignal["SDI"], State = value)) # toggle SCK self.set_signals({"SCK":0}) self.set_signals({"SCK":1}) return True except Exception as details: print("send_bit: Could not set SDA bit on latch: %s", details) return False
def _state_machine(self): time.sleep(.2) # give time for server to startup self.cycle.value = 0 prevCycle = 0 timestamp = time.time() periodic_update = timestamp while not self.EventExit.is_set(): #printi(f'cycle of {self.name}:{self.cycle.value}') waitTime = self.hardPoll.value[0] - (time.time() - timestamp) if waitTime > 0: #print(f'wt {waitTime}') Device.EventExit.wait(waitTime) timestamp = time.time() dt = timestamp - periodic_update if dt > 10.: periodic_update = timestamp #print(f'periodic update: {dt}') self.tempU3.value = D.getTemperature() - 273. self.rps.value = round((self.cycle.value - prevCycle) / dt, 2) prevCycle = self.cycle.value self.cycle.value += 1 # softPulsing pc = int(self.softPulsing.value[0]) if pc > 3: toggle = int(self.cycle.value & 1) D.getFeedback(u3.BitStateWrite(pc, toggle)) # invalidate timestamps for changing variables, otherwise the # publish() will ignore them for i in [ self.tempU3, self.rps, self.cycle, self.AIN, self.FIO4, self.FIO5, self.FIO6, self.FIO7 ]: i.timestamp = timestamp shippedBytes = self.publish() # 1ms #ts3 = timer(); print(f'pub: {ts3-ts2}') print('Labjack ' + self.name + ' exit')
def set_signals(self, signal_dict): """ Sets signals for programming and reading data. The signals are provided as a dictionary with the keys as signal names defined in WBDCsignal. For example: >>> set_signals(LJ,{"SCK":1, "SDA":1,"NLOAD":1, "CS-BUS":1}) Invoked with an empty dictionary it returns the state of the digital I/O ports: In [3]: set_signals(lj[1],{}) Out[3]: [{'CIO': 15, 'EIO': 86, 'FIO': 240}] To give the signals time to settle, a 10 ms wait is included. Until Python 2.6, time.sleep() must be used. @type signal_dict : dictionary @param signal_dict : signal names and states @return: result of u3.BitStateWrite() """ commands = [] for signal,state in list(signal_dict.items()): commands.append(u3.BitStateWrite(WBDCsignal[signal], state)) commands.append(u3.PortStateRead()) #self.logger.debug(" set_signals: sending %s", commands) try: result = self.LJ.getFeedback(commands) #self.logger.debug(" set_signals: command feedback: %s", result) #if float(python_version()[:3]) < 2.6: time.sleep(0.01) except Exception as details: self.logger.error(" set_signals: LJ commands failed:\n%s", details) return result[-1]
def generate_command_lists(self, states): command_lists = [] previous_state = self.default for state in states: command_list = [] # FIOs for i in range(4, 8): if previous_state[i - 4] != state[i - 4]: command_list.append(u3.BitStateWrite(i, state[i - 4])) # DACs if previous_state[4] != state[4]: voltage_in_bits = self._device.voltageToDACBits(volts=state[4], dacNumber=0) command_list.append(u3.DAC0_8(voltage_in_bits)) if previous_state[5] != state[5]: voltage_in_bits = self._device.voltageToDACBits(volts=state[5], dacNumber=1) command_list.append(u3.DAC1_8(voltage_in_bits)) command_lists.append(command_list) previous_state = state return command_lists
def set_state(state): if state: d.getFeedback(u3.BitStateWrite(4, 0)) else: d.getFeedback(u3.BitStateWrite(4, 1))
def setPulse(self): self.labjackModule.getFeedback(u3.BitStateWrite(IONumber=5, State=1)) self.labjackModule.getFeedback(u3.BitStateWrite(IONumber=5, State=0))
def RGB(rgb): # RGB LED connected to EIO7, EIO5, EIO3 if rgb < 8: rgb += 8 threeBits = bin(rgb)[-3:] ch = (15, 13, 11) return [u3.BitStateWrite(ch[i], int(threeBits[i])) for i in range(3)]
def set_DO(self, channel): v = self.par[f'FIO{channel}'].value[0] #print(f'v: {channel,v}') D.getFeedback(u3.BitStateWrite(channel, v))
LabJack.configIO( FIOAnalog=15 ) #is this making a permanent change and wearing out the non-volatile memory? LabJack.getFeedback(u3.BitDirWrite(4, 1)) # Set FIO4 to digital output RelayOFF = not RelayON #always opposite of ON #default power on default for output direction is high. set FIO4 to whatever the relay off logic #requires (and actually reseting if RelayOFF==True just to keep.the logic simpler) #may be able to combine this into one line with the above setting of the output direction? #either way, right now, this seems to be quick enough that the coil doesn't have time to energize. #could use the python command that sets power on defaults in another one time run script/step, #but then that would require an setup step that modifies the device flash memory that would be better to avoid. LabJack.getFeedback(u3.BitStateWrite(4, RelayOFF)) ################################################################ ################################################################ #initialize the LND RPC ################################################################ lnd = LNDClient(LNDhost, network=LNDnetwork, admin=True) ################################################################ ################################################################ #initialize the CAN bus ################################################################
def labjackChildFunction(qTo, qFrom, windowSize=[200, 200], windowPosition=[0, 0]): import sdl2 import sdl2.ext import sys import time try: import appnope appnope.nope() except: pass sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) window = sdl2.ext.Window("labjack", size=windowSize, position=windowPosition, flags=sdl2.SDL_WINDOW_SHOWN) windowID = sdl2.SDL_GetWindowID(window.window) windowSurf = sdl2.SDL_GetWindowSurface(window.window) sdl2.ext.fill(windowSurf.contents, sdl2.pixels.SDL_Color(r=255, g=255, b=255, a=255)) window.refresh() for i in range(10): sdl2.SDL_PumpEvents() #to show the windows import u3 d = u3.U3() d.configU3() d.getCalibrationData() d.configAnalog(u3.FIO0) checkForNextZeroTime = False checkForTrialNextZeroTime = False def exitSafely(): d.close() sys.exit() sendTriggers = False while True: if sendTriggers: if not checkForNextZeroTime: temp = d.getAIN(0) # print temp if temp > .5: #photosensor surpasses criterion d.getFeedback(u3.BitStateWrite(IONumber=8, State=1)) nextZeroTime = time.time( ) + .010 #wait 10ms before setting the state back to zero, giving the amp time to pick it up checkForNextZeroTime = True else: if time.time() >= nextZeroTime: #time to turn the bit back off d.getFeedback(u3.BitStateWrite(IONumber=8, State=0)) checkForNextZeroTime = False if checkForTrialNextZeroTime: if time.time() >= trialNextZeroTime: d.getFeedback(u3.BitStateWrite(IONumber=9, State=0)) checkForTrialNextZeroTime = False if not qTo.empty(): message = qTo.get() if message == 'quit': exitSafely() elif message == 'trialDone': sendTriggers = False checkForTrialNextZeroTime = False checkForNextZeroTime = False d.getFeedback(u3.BitStateWrite( IONumber=8, State=0)) #should be zero, but just in case... d.getFeedback(u3.BitStateWrite( IONumber=9, State=0)) #should be zero, but just in case... elif message == 'trialStart': sendTriggers = True d.getFeedback(u3.BitStateWrite(IONumber=9, State=1)) trialNextZeroTime = time.time( ) + .010 #wait 10ms before setting the state back to zero, giving the amp time to pick it up checkForTrialNextZeroTime = True sdl2.SDL_PumpEvents() for event in sdl2.ext.get_events(): if event.type == sdl2.SDL_WINDOWEVENT: if (event.window.event == sdl2.SDL_WINDOWEVENT_CLOSE): exitSafely()
def DigitalInputOutputAll(ConfigList=[]): ''' Desc: The function that sets FIO pins (4-7) to be either digital input or output. In the latter case both high (3.4 V)or low (0 V) can be specified in the configuration file. The function returns a list of states of all the aforementioned pins: 0 - digital input LOW, 1 - digital input HIGH and 2 - the particular pin is not digital input !!! Remember not to use this function for the pins AIN0-3!!! Ex: >>> LJU3HV.DigitalInputOutputAll(LJU3HV.ReadConfiguration ('C:\Users\Dom\Desktop)) """ FIO4 Mode:DI NegChan:SE LongSettle:F QuickSample:F Property:Temp4 Unit:C P_min:0 P_max:10 V_min[V]:0 V_max[V]:2.44 Dig:L | FIO5 Mode:AI NegChan:SE LongSettle:F QuickSample:F Property:out1 Unit:C P_min:0 P_max:10 V_min[V]:0 V_max[V]:2.44 Dig:L | FIO6 Mode:DO NegChan:SE LongSettle:F QuickSample:F Property:Temp6 Unit:C P_min:0 P_max:10 V_min[V]:0 V_max[V]:2.44 Dig:H | FIO7 Mode:DO NegChan:SE LongSettle:F QuickSample:F Property:Temp7 Unit:C P_min:0 P_max:10 V_min[V]:0 V_max[V]:2.44 Dig:H | """ [0,2,2,2] ''' fioAn = 255 DIResults = [2, 2, 2, 2] for b in range(4, 8): if ConfigList[b][1] != 'Mode:AI': fioAn -= 2**b d.configIO(FIOAnalog=fioAn) for b in range(4, 8): if ConfigList[b][1] == 'Mode:DI': d.getFeedback(u3.BitDirWrite(b, 0)) if d.getFeedback(u3.BitStateRead(b)) == [1]: DIResults[b - 4] = 1 elif d.getFeedback(u3.BitStateRead(b)) == [0]: DIResults[b - 4] = 0 else: pass # 2 given by the defaults means it is not digtal input elif ConfigList[b][1] == 'Mode:DO': print ConfigList[b][11] d.getFeedback(u3.BitDirWrite(b, 1)) if ConfigList[b][11] == 'Dig:L': d.getFeedback(u3.BitStateWrite(b, 0)) if ConfigList[b][11] == 'Dig:H': d.getFeedback(u3.BitStateWrite(b, 1)) return DIResults
# sample for 5s (or CLI specified time) and dump AIN data to stdou if len(sys.argv) > 1: t = int(sys.argv[1]) else: t = 5.0 s = SamplerU3() try: s.start() time.sleep(t) s.stop(wait=1) (rawts, ts, rect, a0, a1, a2, a3,) = s.get() print 'rects,u3clk,hostclk,a0,a1,a2,a3' for n in range(len(rawts)): print '%.2f,%.2f,%.2f,%f,%f,%f,%f' % \ (1000*rect[n], 1000*rawts[n], 1000*ts[n], \ a0[n], a1[n], a2[n], a3[n],) if s.errorcount: sys.stderr.write('%d errors!\n' % s.errorcount) except KeyboardInterrupt: print 'shutting down' k = s.d.getFeedback(u3.BitStateWrite(4, 0), u3.BitStateWrite(5, 1),) s.stop(wait=1) s.d.close()