def __init__(self, vid=FT232H_VID, pid=FT232H_PID):
"""Create a FT232H object. Will search for the first available FT232H
device with the specified USB vendor ID and product ID (defaults to
FT232H default VID & PID).
"""
# Initialize FTDI device connection.
self._ctx = ftdi.new()
if self._ctx == 0:
raise RuntimeError('ftdi_new failed! Is libftdi1 installed?')
# Register handler to close and cleanup FTDI context on program exit.
atexit.register(self.close)
# Open USB connection for specified VID and PID.
self._check(ftdi.usb_open, vid, pid)
# Reset device.
self._check(ftdi.usb_reset)
# Disable flow control. Commented out because it is unclear if this is necessary.
# self._check(ftdi.setflowctrl, ftdi.SIO_DISABLE_FLOW_CTRL)
# Change read & write buffers to maximum size, 65535 bytes.
self._check(ftdi.read_data_set_chunksize, 65535)
self._check(ftdi.write_data_set_chunksize, 65535)
# Clear pending read data & write buffers.
self._check(ftdi.usb_purge_buffers)
# Enable MPSSE and syncronize communication with device.
self._mpsse_enable()
self._mpsse_sync()
# Initialize all GPIO as inputs.
self._write('\x80\x00\x00\x82\x00\x00')
self._direction = 0x0000
self._level = 0x0000
def __init__(self, vid=FT232H_VID, pid=FT232H_PID):
"""Create a FT232H object. Will search for the first available FT232H
device with the specified USB vendor ID and product ID (defaults to
FT232H default VID & PID).
"""
# Initialize FTDI device connection.
self._ctx = ftdi.new()
if self._ctx == 0:
raise RuntimeError('ftdi_new failed! Is libftdi1 installed?')
# Register handler to close and cleanup FTDI context on program exit.
atexit.register(self.close)
# Open USB connection for specified VID and PID.
self._check(ftdi.usb_open, vid, pid)
# Reset device.
self._check(ftdi.usb_reset)
# Disable flow control. Commented out because it is unclear if this is necessary.
#self._check(ftdi.setflowctrl, ftdi.SIO_DISABLE_FLOW_CTRL)
# Change read & write buffers to maximum size, 65535 bytes.
self._check(ftdi.read_data_set_chunksize, 65535)
self._check(ftdi.write_data_set_chunksize, 65535)
# Clear pending read data & write buffers.
self._check(ftdi.usb_purge_buffers)
# Enable MPSSE and syncronize communication with device.
self._mpsse_enable()
self._mpsse_sync()
# Initialize all GPIO as inputs.
self._write('\x80\x00\x00\x82\x00\x00')
self._direction = 0x0000
self._level = 0x0000
def enumerate_device_serials(vid=FT232H_VID, pid=FT232H_PID):
"""Return a list of all FT232H device serial numbers connected to the
machine. You can use these serial numbers to open a specific FT232H device
by passing it to the FT232H initializer's serial parameter.
"""
try:
# Create a libftdi context.
ctx = None
ctx = ftdi.new()
# Enumerate FTDI devices.
device_list = None
count, device_list = ftdi.usb_find_all(ctx, vid, pid)
if count < 0:
raise RuntimeError('ftdi_usb_find_all returned error {0}: {1}'.format(count, ftdi.get_error_string(self._ctx)))
# Walk through list of devices and assemble list of serial numbers.
devices = []
while device_list is not None:
# Get USB device strings and add serial to list of devices.
ret, manufacturer, description, serial = ftdi.usb_get_strings(ctx, device_list.dev, 256, 256, 256)
if serial is not None:
devices.append(serial)
device_list = device_list.next
return devices
finally:
# Make sure to clean up list and context when done.
if device_list is not None:
ftdi.list_free(device_list)
if ctx is not None:
ftdi.free(ctx)
def enumerate_device_serials(vid=FT232H_VID, pid=FT232H_PID):
"""Return a list of all FT232H device serial numbers connected to the
machine. You can use these serial numbers to open a specific FT232H device
by passing it to the FT232H initializer's serial parameter.
"""
try:
# Create a libftdi context.
ctx = None
ctx = ftdi.new()
# Enumerate FTDI devices.
device_list = None
count, device_list = ftdi.usb_find_all(ctx, vid, pid)
if count < 0:
raise RuntimeError('ftdi_usb_find_all returned error {0}: {1}'.format(count, ftdi.get_error_string(self._ctx)))
# Walk through list of devices and assemble list of serial numbers.
devices = []
while device_list is not None:
# Get USB device strings and add serial to list of devices.
ret, manufacturer, description, serial = ftdi.usb_get_strings(ctx, device_list.dev, 256, 256, 256)
if serial is not None:
devices.append(serial)
device_list = device_list.next
return devices
finally:
# Make sure to clean up list and context when done.
if device_list is not None:
ftdi.list_free(device_list)
if ctx is not None:
ftdi.free(ctx)
def __init__(self): self.ftdic = ftdi1.new() print "usb_open ret = ", ftdi1.usb_open(self.ftdic, 0x0403, 0x8c81) print "set_bitmode ret = ", ftdi1.set_bitmode(self.ftdic, 0x00, ftdi1.BITMODE_RESET) # Reset port to normal operation print "set_baudrate ret = ", ftdi1.set_baudrate(self.ftdic, 115200) # 115200 baud print "setflowctrl ret = ", ftdi1.setflowctrl(self.ftdic, ftdi1.SIO_DISABLE_FLOW_CTRL) print "setdtr ret = ", ftdi1.setdtr(self.ftdic, 1) print "setrts ret = ", ftdi1.setrts(self.ftdic, 1)
def open_comms(self):
self.ftdic = ftdi.new()
ret = ftdi.usb_open(self.ftdic, self.idVendor, self.idProduct)
print ret
ret = ftdi.usb_purge_buffers(self.ftdic)
print ret
ret = ftdi.set_bitmode(self.ftdic, 0xFF, ftdi.BITMODE_BITBANG)
print ret
def openDevice(vendor, product, lowByteValue, lowByteDirection):
context = ftdi1.new()
assert context
try:
_ftdi1_check(context, ftdi1.usb_open, vendor, product)
return Mpsse(context, lowByteValue, lowByteDirection)
except:
ftdi1.free(context)
raise
def openDevice(vendor, product, lowByteValue, lowByteDirection): context = ftdi1.new() assert context try: _ftdi1_check(context, ftdi1.usb_open, vendor, product) return Mpsse(context, lowByteValue, lowByteDirection) except: ftdi1.free(context) raise
def __init__(self, vid=FT232H_VID, pid=FT232H_PID, serial=None):
"""Create a FT232H object. Will search for the first available FT232H
device with the specified USB vendor ID and product ID (defaults to
FT232H default VID & PID). Can also specify an optional serial number
string to open an explicit FT232H device given its serial number. See
the FT232H.enumerate_device_serials() function to see how to list all
connected device serial numbers.
"""
# Initialize FTDI device connection.
self._ctx = ftdi.new()
if self._ctx == 0:
raise RuntimeError('ftdi_new failed! Is libftdi1 installed?')
# Register handler to close and cleanup FTDI context on program exit.
atexit.register(self.close)
if serial is None:
# Open USB connection for specified VID and PID if no serial is specified.
self._check(ftdi.usb_open, vid, pid)
else:
# Open USB connection for VID, PID, serial.
##self._check(ftdi.usb_open_string, 's:{0}:{1}:{2}'.format(vid, pid, serial))
finaldev = None
device_list = None
count, device_list = ftdi.usb_find_all(self._ctx, vid, pid)
if count < 0:
raise RuntimeError('ftdi_usb_find_all returned error {0}: {1}'.format(count, ftdi.get_error_string(self._ctx)))
# Walk through list of devices and assemble list of serial numbers.
devices = []
while device_list is not None:
# Get USB device strings and add serial to list of devices.
ret, manufacturer, description, serialtest = ftdi.usb_get_strings(self._ctx, device_list.dev, 256, 256, 256)
if serialtest == serial:
finaldev = device_list.dev
device_list = device_list.next
if finaldev is None:
raise RuntimeError('Could not find correct device')
self._check(ftdi.usb_open_dev, finaldev)
#
# Reset device.
self._check(ftdi.usb_reset)
# Disable flow control. Commented out because it is unclear if this is necessary.
#self._check(ftdi.setflowctrl, ftdi.SIO_DISABLE_FLOW_CTRL)
# Change read & write buffers to maximum size, 65535 bytes.
self._check(ftdi.read_data_set_chunksize, 65535)
self._check(ftdi.write_data_set_chunksize, 65535)
# Clear pending read data & write buffers.
self._check(ftdi.usb_purge_buffers)
# Enable MPSSE and syncronize communication with device.
self._mpsse_enable()
self._mpsse_sync()
# Initialize all GPIO as inputs.
self._write('\x80\x00\x00\x82\x00\x00')
self._direction = 0x0000
self._level = 0x0000
def __init__(self, VID=0x0403, PID=0x6010, _debug_out=None):
"""Open USB connection and initialize FTDI context."""
context = ftdi.new()
if not (ftdi.usb_open(context, VID, PID) == 0):
ftdi.free(context)
self.ftdic = None
raise IOError('could not open USB connection!')
ftdi.set_bitmode(context, 0, ftdi.BITMODE_SYNCFF)
self.ftdic = context
self._debug_ftdi = False
self._debug_out = _debug_out
self._debug_lock = threading.Lock()
def __init__(self,
vid=FT4232H_VID,
pid=FT4232H_PID,
serial=None,
iface=ftdi.INTERFACE_B,
useMPSSE=True):
"""Create a FT232H object. Will search for the first available FT232H
device with the specified USB vendor ID and product ID (defaults to
FT232H default VID & PID). Can also specify an optional serial number
string to open an explicit FT232H device given its serial number. See
the FT232H.enumerate_device_serials() function to see how to list all
connected device serial numbers.
"""
# Initialize FTDI device connection.
self._ctx = ftdi.new()
if self._ctx == 0:
raise RuntimeError('ftdi_new failed! Is libftdi1 installed?')
# Register handler to close and cleanup FTDI context on program exit.
atexit.register(self.close)
ftdi.set_interface(self._ctx, iface)
if serial is None:
# Open USB connection for specified VID and PID if no serial is specified.
self._check(ftdi.usb_open, vid, pid)
else:
# Open USB connection for VID, PID, serial.
self._check(ftdi.usb_open_string,
's:{0}:{1}:{2}'.format(vid, pid, serial))
# Reset device.
self._check(ftdi.usb_reset)
# Disable flow control. Commented out because it is unclear if this is necessary.
#self._check(ftdi.setflowctrl, ftdi.SIO_DISABLE_FLOW_CTRL)
# Change read & write buffers to maximum size, 65535 bytes.
self._check(ftdi.read_data_set_chunksize, 65535)
self._check(ftdi.write_data_set_chunksize, 65535)
# Clear pending read data & write buffers.
self._check(ftdi.usb_purge_buffers)
# Enable MPSSE and syncronize communication with device.
ftdi.set_interface(self._ctx, iface)
self._mpsse_enable()
self._mpsse_sync()
# Initialize all GPIO as inputs.
self._write('\x80\x00\x00\x82\x00\x00')
self._direction = 0x0000
self._level = 0x0000
def main():
"""Main program"""
restart = True
ftdic = ftdi.new()
serial = None
if len(sys.argv) > 1:
serial = sys.argv[1]
ret = ftdi.usb_open_desc(ftdic, 0x0403, 0x6001, None, serial)
if ret < 0:
print("ftdi.usb_open(): %d" % ret, file=sys.stderr)
sys.exit(1)
ret = ftdi.read_eeprom(ftdic)
if ret < 0:
print("ftdi.read_eeprom(): %d" % ret, file=sys.stderr)
sys.exit(1)
ret = ftdi.eeprom_decode(ftdic, True)
if ret < 0:
print("ftdi.eeprom_decode(): %d" % ret, file=sys.stderr)
sys.exit(1)
print()
set_eeprom_value(ftdic, ftdi.CBUS_FUNCTION_0, ftdi.CBUS_TXLED)
set_eeprom_value(ftdic, ftdi.CBUS_FUNCTION_1, ftdi.CBUS_RXLED)
set_eeprom_value(ftdic, ftdi.CBUS_FUNCTION_2, ftdi.CBUS_IOMODE)
set_eeprom_value(ftdic, ftdi.CBUS_FUNCTION_3, ftdi.CBUS_IOMODE)
ret = ftdi.eeprom_build(ftdic);
if ret < 0:
print("ftdi.eeprom_build(): %d" % ret, file=sys.stderr)
sys.exit(1)
print("New EEPROM settings:")
ret = ftdi.eeprom_decode(ftdic, True)
if ret < 0:
print("ftdi.eeprom_decode(): %d" % ret, file=sys.stderr)
sys.exit(1)
ret = ftdi.write_eeprom(ftdic);
if ret < 0:
print("ftdi.write_eeprom(): %d" % ret, file=sys.stderr)
sys.exit(1)
ftdi.free(ftdic)
def __init__(self, pin, debug=DEBUG, overdrive=OVERDRIVE, pullup=None):
self._rmmod()
self._dbg = debug
self._ctx = ftdi.new()
self._level = 0x0000
self._direction = 0x0000
self._buffer = False
self._output = None
self._debug(1, "1Wire: Init")
self._max_buffer = 0
self._overdrive = overdrive
self._od = False
self._rc = False
self._gpiol1 = 5
# Set the pin to use
self.pin = pin
self.pullup = pullup
# Set up delay timers (clock frequencies)
self._reset_clocks(False)
# Two ways to delay. dump a byte to tms, or pulse the clock for n
# bits. A 1 bit pulse seems to take the same as time as a 8bit
# dump to TMS? Default is to pulse the clock.
self.tms_dump = '\x4a\x01\xff' # Dump 8 bits to TMS
self.pb = '\x8e\x01' # Pulse clock (1 bits)
self.delay = self.pb
# MPSSE Command to read GPIO
self.read_gpio = '\x81\x83'
# If we have a pullup pin, set it to low by default, this pin controls
# switching on a strong_pullup if the device needs extra power. It is
# activated when pullup_and_check() is called.
# set_pin() always sets our GPIO flags for our GPIO pin too, so that gets
# done here regardless of having an addition pullup control pin.
if self.pullup is not None:
self.set_pin(self.pullup, False, False)
else:
self.set_pin(self.pin, False, True)
self.write_gpio_state()
# Create the context for FTDI
if self._ctx == 0:
raise Exception("Failed to open FTDI")
atexit.register(self.close)
def id(self): # pylint: disable=invalid-name,too-many-branches,too-many-return-statements
"""Return a unique id for the detected chip, if any."""
# There are some times we want to trick the platform detection
# say if a raspberry pi doesn't have the right ID, or for testing
try:
return os.environ['BLINKA_FORCECHIP']
except KeyError: # no forced chip, continue with testing!
pass
# Special case, if we have an environment var set, we could use FT232H
try:
if os.environ['BLINKA_FT232H']:
# we can't have ftdi1 as a dependency cause its wierd
# to install, sigh.
import ftdi1 as ftdi # pylint: disable=import-error
try:
ctx = None
ctx = ftdi.new() # Create a libftdi context.
# Enumerate FTDI devices.
count, _ = ftdi.usb_find_all(ctx, 0, 0)
if count < 0:
raise RuntimeError(
'ftdi_usb_find_all returned error %d : %s' % count,
ftdi.get_error_string(self._ctx))
if count == 0:
raise RuntimeError('BLINKA_FT232H environment variable' + \
'set, but no FT232H device found')
finally:
# Make sure to clean up list and context when done.
if ctx is not None:
ftdi.free(ctx)
return FT232H
except KeyError: # no FT232H environment var
pass
platform = sys.platform
if platform == "linux" or platform == "linux2":
return self._linux_id()
if platform == "esp8266":
return ESP8266
if platform == "samd21":
return SAMD21
if platform == "pyboard":
return STM32
# nothing found!
return None
def switch(mode):
global c
c = ftdi.new()
# TODO(benjaminfair): error checking
ftdi.usb_open_desc(c, 0x0403, 0x6001, None, os.environ.get("FTDI_SERIAL"))
ftdi.set_bitmode(c, 0xFF, ftdi.BITMODE_BITBANG)
atexit.register(ftdi.free, c)
disable()
if mode == 'run':
set(SWITCH)
elif mode == 'debug':
clear(SWITCH)
elif mode == 'disable':
return
enable()
def main():
"""Main program"""
context = ftdi.new()
version_info = ftdi.get_library_version()
print("[FTDI version] major: %d, minor: %d, micro: %d" \
", version_str: %s, snapshot_str: %s" %
(version_info.major, version_info.minor, version_info.micro,
version_info.version_str, version_info.snapshot_str))
# try to open an ftdi 0x6010 or 0x6001
ret = ftdi.usb_open(context, UM232H_B_VID, UM232H_B_PID)
if ret < 0:
ret = ftdi.usb_open(context, UM232H_B_VID, UM232H_B_PID)
print("ftdi.usb_open(): %d" % ret)
print("ftdi.set_baudrate(): %d" % ftdi.set_baudrate(context, 9600))
ftdi.free(context)
def main():
"""Main program"""
context = ftdi.new()
version_info = ftdi.get_library_version()
print("[FTDI version] major: %d, minor: %d, micro: %d" \
", version_str: %s, snapshot_str: %s" %
(version_info.major, version_info.minor, version_info.micro,
version_info.version_str, version_info.snapshot_str))
# try to open an ftdi 0x6010 or 0x6001
ret = ftdi.usb_open(context, 0x0403, 0x6010)
if ret < 0:
ret = ftdi.usb_open(context, 0x0403, 0x6001)
print("ftdi.usb_open(): %d" % ret)
print("ftdi.set_baudrate(): %d" % ftdi.set_baudrate(context, 9600))
ftdi.free(context)
def __init__(self, *args, **kwargs):
"""
Create a FT232H object. Will search for the first available FT232H
device with the specified USB vendor ID and product ID (defaults to
FT232H default VID & PID). Can also specify an optional serial number
string to open an explicit FT232H device given its serial number.
"""
self._serial = kwargs.get('serial', None)
# Initialize FTDI device connection.
self._bus = ftdi.new()
if self._bus == 0:
raise RuntimeError('ftdi_new failed! Is libftdi1 installed?')
# Register handler to close and cleanup FTDI context on program exit.
atexit.register(self.close)
super(Ft232hGpioInterface, self).__init__(*args, **kwargs)
if self._serial is None:
# Open USB connection for specified VID and PID if no serial is
# specified.
self._check(ftdi.usb_open, self.FT232H_VID, self.FT232H_PID)
else:
# Open USB connection for VID, PID, serial.
self._check(
ftdi.usb_open_string,
's:{0}:{1}:{2}'.format(self.FT232H_VID, self.FT232H_PID,
self._serial))
# Reset device.
self._check(ftdi.usb_reset)
# Disable flow control. It is unclear if this is necessary.
# self._check(ftdi.setflowctrl, ftdi.SIO_DISABLE_FLOW_CTRL)
# Change read & write buffers to maximum size, 65535 bytes.
self._check(ftdi.read_data_set_chunksize, 65535)
self._check(ftdi.write_data_set_chunksize, 65535)
# Clear pending read data & write buffers.
self._check(ftdi.usb_purge_buffers)
# Enable MPSSE and syncronize communication with device.
self._mpsse_enable()
self._mpsse_sync()
# Initialize all GPIO as inputs.
self._write('\x80\x00\x00\x82\x00\x00')
self._direction = 0x0000
self._level = 0x0000
self._log.info("Started interface {0}.".format(self))
def bruteforce_connection_props():
for bits in [ftdi.BITS_8]: #[ftdi.BITS_7, ftdi.BITS_8]:
for sbit in [ftdi.STOP_BIT_1, ftdi.STOP_BIT_15, ftdi.STOP_BIT_2]:
for parity in [
ftdi.NONE, ftdi.ODD, ftdi.EVEN, ftdi.MARK, ftdi.SPACE
]:
for break_ in [ftdi.BREAK_ON]: #, ftdi.BREAK_OFF]:
print(bits, sbit, parity, break_)
ctx = ftdi.new()
ret = ftdi.usb_open(ctx, 0x0760, 0x0002)
assert ret == 0
ret = ftdi.set_baudrate(ctx, 38400)
assert ret == 0, 'baudrate error'
ftdi.set_line_property2(ctx, bits, sbit, parity, break_)
send_msg_led(ctx, 2, 0x49, True)
input('waiting')
ftdi.free(ctx)
def __init__(self, num_pixels, num_rows):
# Create a libftdi context.
ctx = None
ctx = ftdi.new()
# Define USB vendor and product ID
vid = 0x0403
pid = 0x6014
# Enumerate FTDI devices.
self.serial = None
device_list = None
count, device_list = ftdi.usb_find_all(ctx, vid, pid)
while device_list is not None:
# Get USB device strings and add serial to list of devices.
ret, manufacturer, description, serial = ftdi.usb_get_strings(ctx, device_list.dev, 256, 256, 256)
print 'return: {0}, manufacturer: {1}, description: {2}, serial: |{3}|'.format(ret,manufacturer,description,serial)
if 'FTDI' in manufacturer and 'Serial' in description and 'FT' in serial:
self.serial = serial
device_list = device_list.next
# Make sure to clean up list and context when done.
if device_list is not None:
ftdi.list_free(device_list)
if ctx is not None:
ftdi.free(ctx)
# Create an FT232H object.
self.ft232h = FT232H.FT232H(serial=self.serial)
# Create an FT232H object.
self.ft232h = FT232H.FT232H()
# Create a SPI interface for the FT232H object. Set the SPI bus to 6mhz.
self.spi = FT232H.SPI(self.ft232h, max_speed_hz=SPI_BAUD)
# Create a pixel data buffer and lookup table.
self.buffer = bytearray(num_pixels*BYTES_PER_PIXEL*3)
self.lookup = self.build_byte_lookup()
#print self.lookup
self.set_brightness(MAX_INTENSITY/2) #set brightness to 25% by default
self.num_pixels = num_pixels
self.rows = num_rows
self.cols = num_pixels/num_rows
def main():
ctx = ftdi.new()
ret = ftdi.usb_open(ctx, 0x0760, 0x0002)
assert ret == 0, 'ftdi.usb_open error: {}'.format(ret)
ret = ftdi.set_baudrate(ctx, 38400)
assert ret == 0, 'baudrate error'
try:
code.interact(local={
'ctx': ctx,
'ftdi': ftdi,
'read_continuously': read_continuously,
'parse_continuously': parse_continuously,
'send_msg_slider': send_msg_slider,
'send_msg_led': send_msg_led,
'bruteforce_properties': bruteforce_properties,
},
banner='ftdi & ctx imported',
exitmsg='cleaning up!')
finally:
ftdi.free(ctx)
print('done')
def __init__(self, vid=FT232H_VID, pid=FT232H_PID, serial=None):
"""Create a FT232H object. Will search for the first available FT232H
device with the specified USB vendor ID and product ID (defaults to
FT232H default VID & PID). Can also specify an optional serial number
string to open an explicit FT232H device given its serial number. See
the FT232H.enumerate_device_serials() function to see how to list all
connected device serial numbers.
"""
# Initialize FTDI device connection.
self._ctx = ftdi.new()
if self._ctx == 0:
raise RuntimeError('ftdi_new failed! Is libftdi1 installed?')
# Register handler to close and cleanup FTDI context on program exit.
atexit.register(self.close)
if serial is None:
# Open USB connection for specified VID and PID if no serial is specified.
self._check(ftdi.usb_open, vid, pid)
else:
# Open USB connection for VID, PID, serial.
self._check(ftdi.usb_open_string, 's:{0}:{1}:{2}'.format(vid, pid, serial))
# Reset device.
self._check(ftdi.usb_reset)
# Disable flow control. Commented out because it is unclear if this is necessary.
#self._check(ftdi.setflowctrl, ftdi.SIO_DISABLE_FLOW_CTRL)
# Change read & write buffers to maximum size, 65535 bytes.
self._check(ftdi.read_data_set_chunksize, 65535)
self._check(ftdi.write_data_set_chunksize, 65535)
# Clear pending read data & write buffers.
self._check(ftdi.usb_purge_buffers)
# Enable MPSSE and syncronize communication with device.
self._mpsse_enable()
self._mpsse_sync()
# Initialize all GPIO as inputs.
self._write('\x80\x00\x00\x82\x00\x00')
self._direction = 0x0000
self._level = 0x0000
Complete program to demonstrate the usage
of the swig generated python wrapper
You need to build and install the wrapper first"""
import os
import sys
import ftdi1 as ftdi
import time
UM232H_B_VID = 0x0403
UM232H_B_PID = 0x6014
# initialize
ftdic = ftdi.new()
if ftdic == 0:
print('new failed: %d', ret)
os._exit(1)
# try to list ftdi devices 0x6010 or 0x6001
ret, devlist = ftdi.usb_find_all(ftdic, UM232H_B_VID, UM232H_B_PID)
if ret <= 0:
ret, devlist = ftdi.usb_find_all(ftdic, 0x0403, 0x6001)
if ret < 0:
print('ftdi_usb_find_all failed: %d (%s)' %
(ret, ftdi.get_error_string(ftdic)))
os._exit(1)
print('Number of FTDI devices found: %d\n' % ret)
curnode = devlist
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
Tinkering that I did on Fedora 23 using this library:
http://www.intra2net.com/en/developer/libftdi/download/libftdi1-1.2.tar.bz2
'''
import sys
import time
import ftdi1 as ftdi
# My DS_UM232H:
usb_vendor = 0x0403
usb_model = 0x6014
context = ftdi.new()
dev = ftdi.usb_open(context, usb_vendor, usb_model)
if dev < 0:
print 'Failed to open. :-('
while True:
aa, bb = ftdi.read_data(context, 1000)
if aa != 0:
# print bb[:aa],
sys.stdout.write(bb[:aa])
else:
time.sleep(0.01)
import os
import sys
# Import ftdi1 module
import ftdi1 as ftdi
#BAUD, = sys.argv # command line inputs
BAUD = 400000 # 400kHz, 2xNyquist for 100kHz I2C
FT232H_VID = 0x0403 # Default FTDI FT232H vendor ID
FT232H_PID = 0x6014 # Default FTDI FT232H product ID
# Initialize new context
ftdictx = ftdi.new()
if ftdictx == 0:
print( 'failed to create new context: %d', ret )
os._exit( 1 )
# Try to list FT232H devices
ret, devlist = ftdi.usb_find_all( ftdictx, FT232H_VID, FT232H_PID )
if ret < 0:
print( 'ftdi_usb_find_all failed: %d (%s)' % ( ret, ftdi.get_error_string( ftdictx ) ) )
os._exit( 1 )
print( 'Number of FTDI devices found: %d\n' % ret )
curnode = devlist
#i = 0
#while( curnode != None ):
# ret, manufacturer, description, serial = ftdi.usb_get_strings( ftdictx, curnode.dev )
Complete program to demonstrate the usage
of the swig generated python wrapper
You need to build and install the wrapper first"""
import os
import sys
import ftdi1 as ftdi
import time
# version
print ('version: %s\n' % ftdi.__version__)
# initialize
ftdic = ftdi.new()
if ftdic == 0:
print('new failed: %d' % ret)
os._exit(1)
# try to list ftdi devices 0x6010 or 0x6001
ret, devlist = ftdi.usb_find_all(ftdic, 0x0403, 0x6010)
if ret <= 0:
ret, devlist = ftdi.usb_find_all(ftdic, 0x0403, 0x6001)
if ret < 0:
print('ftdi_usb_find_all failed: %d (%s)' %
(ret, ftdi.get_error_string(ftdic)))
os._exit(1)
print('devices: %d' % ret)
curnode = devlist
#!/usr/bin/python3 import ftdi1 f = ftdi1.new() ftdi1.usb_open(f, 0x0403, 0x6001) ftdi1.set_bitmode(f, 1, 0) ftdi1.write_data(f, bytes([0])) ftdi1.write_data(f, bytes([1])) ftdi1.usb_close(f)
def red(context):
actuate(context, RED_ON)
actuate(context, GREEN_OFF)
def green(context):
# turn on Green light
actuate(context, GREEN_ON)
actuate(context, RED_OFF)
def off(context):
actuate(context, RED_OFF)
actuate(context, GREEN_OFF)
context = ftd.new()
ftd.usb_open(context, 0x0403, 0x6001)
ftd.set_bitmode(context, 0xff, ftd.BITMODE_BITBANG)
# Everything off --- shouldn't be necessary.
ftd.write_data(context, bytes([0x00]))
if len(sys.argv) == 1:
off(context)
elif sys.argv[1] == 'red':
red(context)
elif sys.argv[1] == 'green':
green(context)
else:
print("Usage: lavalamps [red|green]")
BLUE2 = ANSI('\033[1;34m')
BG_BLUE = ANSI('\033[0;44m')
MAGENTA = ANSI('\033[0;35m')
MAGENTA2 = ANSI('\033[1;35m')
CYAN = ANSI('\033[0;36m')
CYAN2 = ANSI('\033[1;36m')
WHITE = ANSI('\033[0;37m')
WHITE2 = ANSI('\033[1;37m')
def BIT(x):
return 1 << x
# Initialize FTDI device connection.
ctx = ftdi.new()
ftdi.usb_open(ctx, 0x263d, 0x4001)
ftdi.usb_reset(ctx)
# Disable flow control. Commented out because it is unclear if this is necessary.
#self._check(ftdi.setflowctrl, ftdi.SIO_DISABLE_FLOW_CTRL)
# Change read & write buffers to maximum size, 65535 bytes.
ftdi.read_data_set_chunksize(ctx, 65535)
ftdi.write_data_set_chunksize(ctx, 65535)
# Clear pending read data & write buffers.
ftdi.usb_purge_buffers(ctx)
# Reset MPSSE
ftdi.set_bitmode(ctx, 0, 0)
# Enable MPSSE
if ret < 0:
raise Exception(ftdi1.get_error_string(ftdic))
def read(ftdic, length):
data = '\0' * length
tc = ftdi1.read_data_submit(ftdic, data, length)
if not tc:
raise Exception('FTDI read error')
ret = ftdi1.transfer_data_done(tc)
if ret < 0:
raise Exception(ftdi1.get_error_string(ftdic))
return list(bytearray(data))
ftdic = ftdi1.new()
ftdi1.usb_open_desc_index(ftdic, ftdi_vendor, ftdi_product, None, None, 0)
ftdi1.usb_reset(ftdic)
ftdi1.set_interface(ftdic, ftdi1.INTERFACE_A)
ftdi1.set_bitmode(ftdic, 0, ftdi1.BITMODE_MPSSE)
b = []
# Calculate required clock rate, we bitbang out a clock on the data bit,
# so we need to run at the clock_rate * 2
hz = clock_rate * 2
numerator = 30000000.0
if hz < 1000:
b += cmd(ftdi1.EN_DIV_5)
numerator /= 5.0
else:
def __init__(self):
self.context = ftdi.new()
if self.context == 0:
raise FtdiException("Could not open FTDI context.")
# # Multiple devices plugged in
# if(len(sys.argv) < 3):
# print("Multiple devices plugged in. Please specify an index")
# os._exit(1)
# device = devices[int(sys.argv[2])]
# else:
# # Only one device plugged in
# device = devices[0]
# print(device['path'])
# ret = ftdi.usb_open(ftdic, 0x0403, 0x6001)
print(devices)
ftdics = []
for device in devices:
ret = ftdi.new()
if ret == 0:
print('new failed: %d' % ret)
os._exit(1)
ftdics.append(ret)
for ftdic, device in zip(ftdics, devices):
print(device['path'])
ret = ftdi.usb_open_bus_addr(ftdic, int(device['bus']),
int(device['device']))
if ret < 0:
print('unable to open ftdi device: %d (%s)' %
(ret, ftdi.get_error_string(ftdic)))
os._exit(1)
if (sys.argv[1] == "bootload"):
