def main():
""" Send/receive data from the Papilio FPGA using the high speed
mode of the FT232H.
"""
# Create the device list.
num_devices = ft.createDeviceInfoList()
if (num_devices == 0):
print "No devices found."
sys.exit();
print "Found {0} devices.".format(num_devices)
# Get the device information for the device with sync FIFO mode.
device_info = None
device_index = 0
for index in range(0, num_devices):
device_info = ft.getDeviceInfoDetail(devnum = index, update = False)
if (device_info['description'] == 'UM232H_245FIFO'):
device_index = index
break
if (device_info == None):
print "Device not found."
sys.exit()
# Open the device and configure for sync FIFO mode.
ft.setVIDPID(0x0403, 0x6014)
device = ft.open(dev = device_index)
device.setBitMode(0xFF, 0x00) # Reset mode
sleep(.01)
device.setBitMode(0xFF, 0x40) # Sync FIFO mode
device.setLatencyTimer(2) # Receive buffer timeout in msec
device.setUSBParameters(4096, 4096) # Set transfer in/out size to 4096
device.setFlowControl(FLOW_RTS_CTS, 0, 0) # Flow control method
def open(
self
): # This method must return a string showing whether the open succeeded or failed.
enum = d2xx.createDeviceInfoList() # quantity of FTDI devices
if (enum == 0):
return 'Device was not found'
for i in range(enum): # Searching and openinq needed device
a = d2xx.getDeviceInfoDetail(i)
if (a['description'] == 'SDR-Micron'):
try:
self.usb = d2xx.openEx(a['serial'])
except:
return 'Device was not found'
Mode = 64 # Configure FT2232H into 0x40 Sync FIFO Mode
self.usb.setBitMode(255, 0) # reset
time.sleep(0.1)
self.usb.setBitMode(
255, Mode) #configure FT2232H into Sync FIFO mode
self.usb.setTimeouts(100, 100) # read, write
self.usb.setLatencyTimer(2)
self.usb.setUSBParameters(64, 64) # in_tx_size, out_tx_size=0
time.sleep(1.5) # waiting for initialisation device
data = self.usb.read(
self.usb.getQueueStatus()) # clean the usb data buffer
self.device = 'Opened'
self.frame_msg = a['description'] + ' S/N - ' + a['serial']
return self.frame_msg
return 'Device was not found'
def __init__(self, param_dict):
param_dict = self._translate_dict_values(param_dict, self.ftd2xx_dict)
[setattr(self, key, val) for key, val in param_dict.items()]
self.n_bytes = param_dict["n_bytes"]
# auto-find UM232H serial number
num_devs = ftd2xx.createDeviceInfoList()
for idx in range(num_devs):
info_dict = ftd2xx.getDeviceInfoDetail(devnum=idx)
if info_dict["description"] == b"UM232H":
self.serial = info_dict["serial"]
def _find_some_simps(self):
# Determine the number of devices. This is a slow call.
number_of_devices = ftd2xx.createDeviceInfoList()
# For each FTDI device using the D2XX drivers, get and check the device description for a simp.
devices = []
for index in range(number_of_devices):
try:
# Update is false to prevent another slow createDeviceInfoList call.
device_details = ftd2xx.getDeviceInfoDetail(index, update=False)
if (device_details['description'] == b'SIMPS Device'):
devices.append(device_details)
elif (device_details['description'] == b'SIMPS ATE'):
devices.append(device_details)
except ftd2xx.ftd2xx.DeviceError:
pass
return devices
def testcreateDeviceInfoList(self):
self.assert_(isinstance(ftd2xx.createDeviceInfoList(), long))
def testcreateDeviceInfoList(self):
self.assert_(isinstance(ftd2xx.createDeviceInfoList(), long))
def testcreateDeviceInfoList(self):
self.assertTrue(isinstance(ftd2xx.createDeviceInfoList(), int))
def __init__(self,hwser=None):
# Find out how many ftd2xx devices are connected to the USB bus
numDevices=ftd2xx.createDeviceInfoList()
# Check each device to see if either the serial number matches (if given) or the description string is recognized as valid for the class type
numMatchingDevices=0
for dev in range(numDevices):
detail=ftd2xx.getDeviceInfoDetail(dev)
if hwser!=None and detail["serial"]!="" and int(detail["serial"])==hwser:
# Get the first device which matches the serial number if given
numMatchingDevices+=1
self.device=device=ftd2xx.open(dev)
break
elif hwser==None and (detail["description"] in self.deviceDescriptionStrings()):
# Get the first device which is valid for the given class if no hwser
numMatchingDevices+=1
if numMatchingDevices==1:
self.device=device=ftd2xx.open(dev)
elif dev==numDevices-1 and numMatchingDevices==0:
# Raise an exception if no devices were found
if hwser!=None:
errorStr="Hardware serial number " + str(hwser) + " was not found"
else:
errorStr="No devices found matching class name " + type(self).__name__ + ". Expand the definition of CLASS_STRING_MAPPING if necessary"
raise DeviceNotFoundError, errorStr
# Print a warning message if no serial given and multiple devices were found which matched the class type
if numMatchingDevices>1 and hwser==None:
print(str(numMatchingDevices)+" devices found matching " + type(self).__name__ + "; the first device was opened")
# Inititalize the device according to FTD2xx and APT requirements
device.setBaudRate(ftd2xx.defines.BAUD_115200)
device.setDataCharacteristics(ftd2xx.defines.BITS_8,ftd2xx.defines.STOP_BITS_1,ftd2xx.defines.PARITY_NONE)
self.delay()
device.purge()
self.delay()
device.resetDevice()
device.setFlowControl(ftd2xx.defines.FLOW_RTS_CTS)
device.setTimeouts(c.WRITE_TIMEOUT,c.READ_TIMEOUT)
# Check first 2 digits of serial number to see if it's normal type or card/slot type, and build self.channelAddresses as list of (chanID,destAddress) tuples
self.channelAddresses=[]
if device.serial[0:2] in c.BAY_TYPE_SERIAL_PREFIXES:
# Get the device info
serNum,model,hwtype,firmwareVer,notes,hwVer,modState,numCh=self.query(c.MGMSG_HW_REQ_INFO,c.MGMSG_HW_GET_INFO,destID=c.RACK_CONTROLLER_ID)[-1]
# Check each bay to see if it's enabled and also request hardware info
for bay in range(numCh):
bayId=c.ALL_BAYS[bay]
self.writeMessage(c.MGMSG_HW_NO_FLASH_PROGRAMMING,destID=bayId)
if self.BayUsed(bay):
bayInfo=self.query(c.MGMSG_HW_REQ_INFO,c.MGMSG_HW_GET_INFO,destID=bayId)[-1]
self.channelAddresses.append((c.CHANNEL_1,bayId))
else:
# Otherwise just build a list of the channel numbers
self.writeMessage(c.MGMSG_HW_NO_FLASH_PROGRAMMING,destID=c.GENERIC_USB_ID)
serNum,model,hwtype,firmwareVer,notes,hwVer,modState,numCh=self.query(c.MGMSG_HW_REQ_INFO,c.MGMSG_HW_GET_INFO)[-1]
for channel in range(numCh):
self.channelAddresses.append((c.ALL_CHANNELS[channel],c.GENERIC_USB_ID))
for channel in range(len(self.channelAddresses)):
self.writeMessage(c.MGMSG_MOD_SET_CHANENABLESTATE,1,c.CHAN_ENABLE_STATE_ENABLED,c.RACK_CONTROLLER_ID)
self.EnableHWChannel(channel)
# Set the controller type
self.controllerType=model.replace("\x00","").strip()
# Print a message saying we've connected to the device successfuly
print("Connected to %s device with serial number %d. Notes about device: %s"%(model.replace('\x00', ''),serNum,notes.replace('\x00', '')))
import ftd2xx
import pprint
devNum = ftd2xx.createDeviceInfoList()
getDeviceInfoDetail = [
ftd2xx.getDeviceInfoDetail(devnum=i, update=False) for i in range(devNum)
]
dev = ftd2xx.open(0)
dev.setChars(False, 0, False, 0)
dev.setTimeouts(5000, 5000)
dev.setLatencyTimer(2)
dev.setBaudRate(300)
AsynchronousBitBang = 0x01
dev.setBitMode(0x00, AsynchronousBitBang)
value = None
while True:
rxBytes = dev.getQueueStatus()
if rxBytes:
rxbuffer = dev.read(rxBytes)
newValue = rxbuffer[-1]
if value != newValue:
print(hex(newValue))
value = newValue
