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()
