Ejemplo n.º 1
0
 def close(self):
     """
     Close the FTDI device. Will be automatically called when the program ends.
     """
     if self._bus is not None:
         ftdi.free(self._bus)
     self._bus = None
Ejemplo n.º 2
0
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)
Ejemplo n.º 3
0
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)
Ejemplo n.º 4
0
 def close(self):
     if self._ctx is not None:
         self._debug(3, "MPSSE: Max buffer: {}".format(self._max_buffer))
         self._debug(3, "MPSSE: Closed. FTDI Released")
         ftdi.free(self._ctx)
     self._ctx = None
     self._od = False
     self._rc = False
Ejemplo n.º 5
0
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
Ejemplo n.º 6
0
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
Ejemplo n.º 7
0
 def __exit__(self, *args):
     """Deinitialize FTDI context and close USB connection."""
     self.purge()
     self.reset()
     if self.ftdic is not None:
         #ftdi.set_bitmode(self.ftdic, 0, ftdi.BITMODE_RESET)
         ftdi.free(self.ftdic)
                 # free -> deinit -> usb_close_internal -> usb_close
     if self._debug_ftdi:
         self._debug("[FTDI] exit")
Ejemplo n.º 8
0
	def __del__(self):


		# close usb
		ret = ftdi1.usb_close(self.ftdic)
		if ret < 0:
			print('unable to close ftdi device: %d (%s)' % (ret, ftdi1.get_error_string(self.ftdic)))
		    

		print ('device closed')
		ftdi1.free(self.ftdic)
Ejemplo n.º 9
0
 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()
Ejemplo n.º 10
0
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)
Ejemplo n.º 11
0
    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
Ejemplo n.º 12
0
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)
Ejemplo n.º 13
0
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)
Ejemplo n.º 14
0
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)
Ejemplo n.º 15
0
	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
Ejemplo n.º 16
0
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')
Ejemplo n.º 17
0
print 'Gathering data. Press Ctrl-C to quit.'
output = []
try:
    while True:
	    # Sleep based on baudrate
        time.sleep(1.0/BAUD)
	    # Read the input and store to array
        ret, pins = ftdi.read_pins(ftdictx)			# reads pins directly, needs sleep time to be exact
        output.append(pins)
        #ret, databuf = ftdi.read_data(ftdictx)		# reads the data buffer, no need for exact timing (just fast enough to keep buffer from overflowing)
        #output.extend(databuf)
except KeyboardInterrupt:
    pass

## Write captured data to file
with open("output.bin", "wb") as outfile:
    writedata = bytearray(output)
    outfile.write(writedata)

## Cleanup: free devlist, reset bitmode, close usb, etc
ftdi.list_free(devlist)
ftdi.disable_bitbang(ftdictx)
ftdi.set_bitmode(ftdictx, 0x00, ftdi.BITMODE_RESET)
ret = ftdi.usb_close( ftdictx )
if ret < 0:
    print( 'unable to close ftdi device: %d (%s)' % ( ret, ftdi.get_error_string( ftdictx ) ) )
    os._exit( 1 )
    
print ('device closed')    
ftdi.free( ftdictx )
Ejemplo n.º 18
0
 def close(self):
     """Close the FTDI device.  Will be automatically called when the program ends."""
     if self._ctx is not None:
         ftdi.free(self._ctx)
     self._ctx = None
Ejemplo n.º 19
0
# read eeprom
eeprom_addr = 1
ret, eeprom_val = ftdi.read_eeprom_location(ftdic, eeprom_addr)
if (ret == 0):
    print('eeprom @ %d: 0x%04x\n' % (eeprom_addr, eeprom_val))

print('eeprom:')
ret = ftdi.read_eeprom(ftdic)
size = 128
ret, eeprom = ftdi.get_eeprom_buf(ftdic, size)
if (ret == 0):
    for i in range(size):
        octet = eeprom[i]
        if sys.version_info[0] < 3:  # python 2
            octet = ord(octet)
        sys.stdout.write('%02x ' % octet)
        if (i % 8 == 7):
            print('')
print('')

# close usb
ret = ftdi.usb_close(ftdic)
if ret < 0:
    print('unable to close ftdi device: %d (%s)' %
          (ret, ftdi.get_error_string(ftdic)))
    os._exit(1)

print ('device closed')
ftdi.free(ftdic)
Ejemplo n.º 20
0
# read eeprom
eeprom_addr = 1
ret, eeprom_val = ftdi.read_eeprom_location(ftdic, eeprom_addr)
if (ret == 0):
    print('eeprom @ %d: 0x%04x\n' % (eeprom_addr, eeprom_val))

print('eeprom:')
ret = ftdi.read_eeprom(ftdic)
size = 128
ret, eeprom = ftdi.get_eeprom_buf(ftdic, size)
if (ret == 0):
    for i in range(size):
        if isinstance(eeprom[i], str):
            octet = ord(eeprom[i])  # python2
        else:
            octet = eeprom[i]  # python3
        sys.stdout.write('%02x ' % octet)
        if (i % 8 == 7):
            print('')
print('')

# close usb
ret = ftdi.usb_close(ftdic)
if ret < 0:
    print('unable to close ftdi device: %d (%s)' %
          (ret, ftdi.get_error_string(ftdic)))
    os._exit(1)

print('device closed')
ftdi.free(ftdic)
Ejemplo n.º 21
0
 def __exit__(self, exeptype, value, traceback):
     ftdi.free(self.context)