"""

returnDict = dict()

for i in range(deviceCount(3)):

d = U3(firstFound = False, devNumber = i+1)

returnDict[str(d.serialNumber)] = d

"""

def __init__(self, debug = False, autoOpen = True, **kargs):

"""

Device.__init__(self, None, devType = 3)

self.debug = debug

self.calData = None

self.ledState = True

if autoOpen:

self.open(**kargs)

__init__.section = 1

def open(self, firstFound = True, serial = None, localId = None, devNumber = None, handleOnly = False, LJSocket = None):

"""

Device.open(self, 3, firstFound = firstFound, serial = serial, localId = localId, devNumber = devNumber, handleOnly = handleOnly, LJSocket = LJSocket )

open.section = 1

def configU3(self, LocalID = None, TimerCounterConfig = None, FIOAnalog = None, FIODirection = None, FIOState = None, EIOAnalog = None, EIODirection = None, EIOState = None, CIODirection = None, CIOState = None, DAC1Enable = None, DAC0 = None, DAC1 = None, TimerClockConfig = None, TimerClockDivisor = None, CompatibilityOptions = None):

"""

writeMask = 0

if FIOAnalog is not None or FIODirection is not None or FIOState is not None or EIOAnalog is not None or EIODirection is not None or EIOState is not None or CIODirection is not None or CIOState is not None:

writeMask |= 2

if DAC1Enable is not None or DAC0 is not None or DAC1 is not None:

writeMask |= 4

if LocalID is not None:

writeMask |= 8

if TimerClockConfig is not None or TimerClockDivisor is not None:

writeMask |= 16

if CompatibilityOptions is not None:

writeMask |= 32

command = [ 0 ] * 26

#command[0] = Checksum8

command[1] = 0xF8

command[2] = 0x0A

command[3] = 0x08

#command[4] = Checksum16 (LSB)

#command[5] = Checksum16 (MSB)

command[6] = writeMask

#command[7] = WriteMask1

if LocalID is not None:

command[8] = LocalID

if TimerCounterConfig is not None:

command[9] = TimerCounterConfig

if FIOAnalog is not None:

command[10] = FIOAnalog

if FIODirection is not None:

command[11] = FIODirection

if FIOState is not None:

command[12] = FIOState

if EIOAnalog is not None:

command[13] = EIOAnalog

if EIODirection is not None:

command[14] = EIODirection

if EIOState is not None:

command[15] = EIOState

if CIODirection is not None:

command[16] = CIODirection

if CIOState is not None:

command[17] = CIOState

if DAC1Enable is not None:

command[18] = DAC1Enable

if DAC0 is not None:

command[19] = DAC0

if DAC1 is not None:

command[20] = DAC1

if TimerClockConfig is not None:

command[21] = TimerClockConfig

if TimerClockDivisor is not None:

command[22] = TimerClockDivisor

if CompatibilityOptions is not None:

command[23] = CompatibilityOptions

result = self._writeRead(command, 38, [0xF8, 0x10, 0x08])

# Error-free, time to parse the response

self.firmwareVersion = "%d.%02d" % (result[10], result[9])

self.bootloaderVersion = "%d.%02d" % (result[12], result[11])

self.hardwareVersion = "%d.%02d" % (result[14], result[13])

self.serialNumber = unpack("<I", pack(">BBBB", *result[15:19]))[0]

self.productId = unpack("<H", pack(">BB", *result[19:21]))[0]

self.localId = result[21]

self.timerCounterMask = result[22]

self.fioAnalog = result[23]

self.fioDirection = result[24]

self.fioState = result[25]

self.eioAnalog = result[26]

self.eioDirection = result[27]

self.eioState = result[28]

self.cioDirection = result[29]

self.cioState = result[30]

self.dac1Enable = result[31]

self.dac0 = result[32]

self.dac1 = result[33]

self.timerClockConfig = result[34]

self.timerClockDivisor = result[35]

if result[35] == 0:

self.timerClockDivisor = 256

self.compatibilityOptions = result[36]

self.versionInfo = result[37]

self.deviceName = 'U3'

self.isHV = False

if self.versionInfo == 1:

self.deviceName += 'B'

elif self.versionInfo == 2:

self.deviceName += '-LV'

elif self.versionInfo == 18:

self.deviceName += '-HV'

self.isHV = True

return {'FirmwareVersion': self.firmwareVersion, 'BootloaderVersion': self.bootloaderVersion, 'HardwareVersion': self.hardwareVersion, 'SerialNumber': self.serialNumber, 'ProductID': self.productId, 'LocalID': self.localId, 'TimerCounterMask': self.timerCounterMask, 'FIOAnalog': self.fioAnalog, 'FIODirection': self.fioDirection, 'FIOState': self.fioState, 'EIOAnalog': self.eioAnalog, 'EIODirection': self.eioDirection, 'EIOState': self.eioState, 'CIODirection': self.cioDirection, 'CIOState': self.cioState, 'DAC1Enable': self.dac1Enable, 'DAC0': self.dac0, 'DAC1': self.dac1, 'TimerClockConfig': self.timerClockConfig, 'TimerClockDivisor': self.timerClockDivisor, 'CompatibilityOptions': self.compatibilityOptions, 'VersionInfo': self.versionInfo, 'DeviceName': self.deviceName}

configU3.section = 2

def configIO(self, TimerCounterPinOffset = None, EnableCounter1 = None, EnableCounter0 = None, NumberOfTimersEnabled = None, FIOAnalog = None, EIOAnalog = None, EnableUART = None):

"""

writeMask = 0

if EIOAnalog is not None:

writeMask |= 1

writeMask |= 8

if FIOAnalog is not None:

writeMask |= 1

writeMask |= 4

if EnableUART is not None:

writeMask |= 1

writeMask |= (1 << 5)

if TimerCounterPinOffset is not None or EnableCounter1 is not None or EnableCounter0 is not None or NumberOfTimersEnabled is not None :

writeMask |= 1

command = [ 0 ] * 12

#command[0] = Checksum8

command[1] = 0xF8

command[2] = 0x03

command[3] = 0x0B

#command[4] = Checksum16 (LSB)

#command[5] = Checksum16 (MSB)

command[6] = writeMask

#command[7] = Reserved

command[8] = 0

if EnableUART is not None and EnableUART:

command[9] = 1 << 2

if TimerCounterPinOffset is None:

command[8] |= ( 4 & 15 ) << 4

else:

command[8] |= ( TimerCounterPinOffset & 15 ) << 4

if EnableCounter1 is not None and EnableCounter1:

command[8] |= 1 << 3

if EnableCounter0 is not None and EnableCounter0:

command[8] |= 1 << 2

if NumberOfTimersEnabled is not None:

command[8] |= ( NumberOfTimersEnabled & 3 )

if FIOAnalog is not None:

command[10] = FIOAnalog

if EIOAnalog is not None:

command[11] = EIOAnalog

result = self._writeRead(command, 12, [0xF8, 0x03, 0x0B])

self.timerCounterConfig = result[8]

self.numberTimersEnabled = self.timerCounterConfig & 3

self.counter0Enabled = bool( (self.timerCounterConfig >> 2) & 1 )

self.counter1Enabled = bool( (self.timerCounterConfig >> 3) & 1 )

self.timerCounterPinOffset = ( self.timerCounterConfig >> 4 )

self.dac1Enable = result[9]

self.fioAnalog = result[10]

self.eioAnalog = result[11]

return { 'TimerCounterConfig' : self.timerCounterConfig, 'DAC1Enable' : self.dac1Enable, 'FIOAnalog' : self.fioAnalog, 'EIOAnalog' : self.eioAnalog, 'NumberOfTimersEnabled' : self.numberTimersEnabled, 'EnableCounter0' : self.counter0Enabled, 'EnableCounter1' : self.counter1Enabled, 'TimerCounterPinOffset' : self.timerCounterPinOffset }

configIO.section = 2

def configTimerClock(self, TimerClockBase = None, TimerClockDivisor = None):

"""

command = [ 0 ] * 10

#command[0] = Checksum8

command[1] = 0xF8

command[2] = 0x02

command[3] = 0x0A

#command[4] = Checksum16 (LSB)

#command[5] = Checksum16 (MSB)

#command[6] = Reserved

#command[7] = Reserved

if TimerClockBase is not None:

command[8] = ( 1 << 7 ) + ( TimerClockBase & 7 )

if TimerClockDivisor is not None:

command[9] = TimerClockDivisor

elif TimerClockDivisor is not None:

raise LabJackException("You can't set just the divisor, must set both.")

result = self._writeRead(command, 10, [0xf8, 0x02, 0x0A])

self.timerClockBase = ( result[8] & 7 )

self.timerClockDivisor = result[9]

return { 'TimerClockBase' : self.timerClockBase, 'TimerClockDivisor' : self.timerClockDivisor }

configTimerClock.section = 2

def toggleLED(self):

"""

self.getFeedback( LED( not self.ledState ) )

self.ledState = not self.ledState

toggleLED.section = 3

def setFIOState(self, fioNum, state = 1):

"""

self.getFeedback(BitDirWrite(fioNum, 1), BitStateWrite(fioNum, state))

setFIOState.section = 3

def getFIOState(self, fioNum):

"""

return self.getFeedback(BitStateRead(fioNum))[0]

getFIOState.section = 3

def setDOState(self, ioNum, state = 1):

"""

self.getFeedback(BitDirWrite(ioNum, 1), BitStateWrite(ioNum, state))

setDOState.section = 3

def getDIState(self, ioNum):

"""

return self.getFeedback(BitDirWrite(ioNum, 0), BitStateRead(ioNum))[1]

getDIState.section = 3

def getDIOState(self, ioNum):

"""

return self.getFeedback(BitStateRead(ioNum))[0]

getDIOState.section = 3

def getTemperature(self):

"""

# Get the calibration data first, otherwise the conversion is way off (10 degC on my U3)

if self.calData is None:

self.getCalibrationData()

bits, = self.getFeedback( AIN(30, 31) )

return self.binaryToCalibratedAnalogTemperature(bits)

def getAIN(self, posChannel, negChannel = 31, longSettle=False, quickSample=False):

"""

isSpecial = False

if negChannel == 32:

isSpecial = True

negChannel = 30

bits = self.getFeedback(AIN(posChannel, negChannel, longSettle, quickSample))[0]

singleEnded = True

if negChannel != 31:

singleEnded = False

lvChannel = True

try:

if self.isHV and posChannel < 4:

lvChannel = False

except AttributeError:

pass

if isSpecial:

negChannel = 32

return self.binaryToCalibratedAnalogVoltage(bits, isLowVoltage = lvChannel, isSingleEnded = singleEnded, isSpecialSetting = isSpecial, channelNumber = posChannel)

getAIN.section = 3

def configAnalog(self, *args):

"""

configIODict = self.configIO()

# Without args, return the same as configIO()

if len(args) == 0:

return configIODict

FIOAnalog, EIOAnalog = configIODict['FIOAnalog'], configIODict['EIOAnalog']

#

for i in args:

if i > EIO7:

pass # Invalid. Must be in the range FIO0-EIO7.

elif i < EIO0:

FIOAnalog |= 2**i

else:

EIOAnalog |= 2**(i-EIO0) # Start the EIO counting at 0, not 8

return self.configIO(FIOAnalog = FIOAnalog, EIOAnalog = EIOAnalog)

def configDigital(self, *args):

"""

configIODict = self.configIO()

# Without args, return the same as configIO()

if len(args) == 0:

return configIODict

FIOAnalog, EIOAnalog = configIODict['FIOAnalog'], configIODict['EIOAnalog']

#

for i in args:

if i > EIO7:

pass # Invalid. Must be in the range FIO0-EIO7.

elif i < EIO0:

if FIOAnalog & 2**i: # If it is set

FIOAnalog ^= 2**i # Remove it

else:

if EIOAnalog & 2**(i-EIO0): # Start the EIO counting at 0, not 8

EIOAnalog ^= 2**(i-EIO0)

return self.configIO(FIOAnalog = FIOAnalog, EIOAnalog = EIOAnalog)

def _buildBuffer(self, sendBuffer, readLen, commandlist):

"""

for cmd in commandlist:

if isinstance(cmd, FeedbackCommand):

sendBuffer += cmd.cmdBytes

readLen += cmd.readLen

elif isinstance(cmd, list):

sendBuffer, readLen = self._buildBuffer(sendBuffer, readLen, cmd)

return (sendBuffer, readLen)

_buildBuffer.section = 4

def _buildFeedbackResults(self, rcvBuffer, commandlist, results, i):

"""

for cmd in commandlist:

if isinstance(cmd, FeedbackCommand):

results.append(cmd.handle(rcvBuffer[i:i+cmd.readLen]))

i += cmd.readLen

elif isinstance(cmd, list):

self._buildFeedbackResults(rcvBuffer, cmd, results, i)

return results

_buildFeedbackResults.section = 4

def getFeedback(self, *commandlist):

"""

sendBuffer = [0] * 7

sendBuffer[1] = 0xF8

readLen = 9

sendBuffer, readLen = self._buildBuffer(sendBuffer, readLen, commandlist)

if len(sendBuffer) % 2:

sendBuffer += [0]

sendBuffer[2] = len(sendBuffer) // 2 - 3

if readLen % 2:

readLen += 1

if len(sendBuffer) > MAX_USB_PACKET_LENGTH:

raise LabJackException("ERROR: The feedback command you are attempting to send is bigger than 64 bytes ( %s bytes ). Break your commands up into separate calls to getFeedback()." % len(sendBuffer))

if readLen > MAX_USB_PACKET_LENGTH:

raise LabJackException("ERROR: The feedback command you are attempting to send would yield a response that is greater than 64 bytes ( %s bytes ). Break your commands up into separate calls to getFeedback()." % readLen)

rcvBuffer = self._writeRead(sendBuffer, readLen, [], checkBytes = False, stream = False, checksum = True)

# Check the response for errors

try:

self._checkCommandBytes(rcvBuffer, [0xF8])

if rcvBuffer[3] != 0x00:

raise LabJackException("Got incorrect command bytes")

except LowlevelErrorException:

if isinstance(commandlist[0], list):

culprit = commandlist[0][ (rcvBuffer[7] -1) ]

else:

culprit = commandlist[ (rcvBuffer[7] -1) ]

raise LowlevelErrorException("\nThis Command\n %s\nreturned an error:\n %s" % (culprit , lowlevelErrorToString(rcvBuffer[6])))

results = []

i = 9

return self._buildFeedbackResults(rcvBuffer, commandlist, results, i)

getFeedback.section = 2

def readMem(self, blockNum, readCal=False):

"""

command = [ 0 ] * 8

#command[0] = Checksum8

command[1] = 0xF8

command[2] = 0x01

command[3] = 0x2A

if readCal:

command[3] = 0x2D

#command[4] = Checksum16 (LSB)

#command[5] = Checksum16 (MSB)

command[6] = 0x00

command[7] = blockNum

result = self._writeRead(command, 40, [0xF8, 0x11, command[3]])

return result[8:]

readMem.section = 2

def readCal(self, blockNum):

"""

return self.readMem(blockNum, readCal = True)

readCal.section = 2

def writeMem(self, blockNum, data, writeCal=False):

"""

if not isinstance(data, list):

raise LabJackException("Data must be a list of bytes")

command = [ 0 ] * 40

#command[0] = Checksum8

command[1] = 0xF8

command[2] = 0x11

command[3] = 0x28

if writeCal:

command[3] = 0x2B

#command[4] = Checksum16 (LSB)

#command[5] = Checksum16 (MSB)

command[6] = 0x00

command[7] = blockNum

command[8:] = data

self._writeRead(command, 8, [0xF8, 0x01, command[3]])

writeMem.section = 2

def writeCal(self, blockNum, data):

"""

return self.writeMem(blockNum, data, writeCal = True)

writeCal.section = 2

def eraseMem(self, eraseCal=False):

"""

if not isinstance(eraseCal, bool):

raise LabJackException("eraseCal must be a Boolean value (True or False).")

if eraseCal:

command = [ 0 ] * 8

#command[0] = Checksum8

command[1] = 0xF8

command[2] = 0x01

command[3] = 0x2C

#command[4] = Checksum16 (LSB)

#command[5] = Checksum16 (MSB)

command[6] = 0x4C

command[7] = 0x6C

else:

command = [ 0 ] * 6

#command[0] = Checksum8

command[1] = 0xF8

command[2] = 0x00

command[3] = 0x29

#command[4] = Checksum16 (LSB)

#command[5] = Checksum16 (MSB)

self._writeRead(command, 8, [0xF8, 0x01, command[3]])

eraseMem.section = 2

def eraseCal(self):

"""

return self.eraseMem(eraseCal = True)

eraseCal.section = 2

def reset(self, hardReset = False):

"""

command = [ 0 ] * 4

#command[0] = Checksum8

command[1] = 0x99

command[2] = 1

if hardReset:

command[2] = 2

command[3] = 0x00

command = setChecksum8(command, 4)

self._writeRead(command, 4, [], False, False, False)

reset.section = 2

def streamConfig(self, NumChannels = 1, SamplesPerPacket = 25, InternalStreamClockFrequency = 0, DivideClockBy256 = False, Resolution = 3, ScanInterval = 1, PChannels = [30], NChannels = [31], ScanFrequency = None, SampleFrequency = None):

"""