PyFtdi

https://eblot.github.io/pyftdi
Admin
PyFtdi is a user-space Python driver for FTDI USB devices providing UART, GPIO, SPI, I2C, and JTAG...
Tokens:41,721
Snippets:333
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install PyFTDI from source

Source: https://eblot.github.io/pyftdi/installation.html

Installs PyFTDI by cloning the repository and using setup.py, allowing for development or installation from the latest source code.

```bash
git clone https://github.com/eblot/pyftdi.git
cd pyftdi
# note: 'pip3' may simply be 'pip' on some hosts
pip3 install -r requirements.txt
python3 setup.py install
```

--------------------------------

### Install PyFTDI dependencies from source

Source: https://eblot.github.io/pyftdi/installation.html

Installs required dependencies for PyFTDI from a requirements file when installing from source.

```python
pip3 install -r requirements.txt
```

--------------------------------

### Start a subshell with plugdev group privileges

Source: https://eblot.github.io/pyftdi/installation.html

Starts a new shell session with the 'plugdev' group active, allowing testing of PyFTDI without logging out and back in.

```bash
newgrp plugdev
```

--------------------------------

### Generate PyFTDI documentation

Source: https://eblot.github.io/pyftdi/installation.html

Installs necessary tools and builds the HTML documentation for PyFTDI using Sphinx.

```python
pip3 install setuptools wheel sphinx sphinx_autodoc_typehints
# Shpinx Read the Doc theme seems to never get a release w/ fixed issues
pip3 install -U -e git+https://github.com/readthedocs/sphinx_rtd_theme.git@2b8717a3647cc650625c566259e00305f7fb60aa#egg=sphinx_rtd_theme
sphinx-build -b html pyftdi/doc .
```

--------------------------------

### Install libusb on macOS using Homebrew

Source: https://eblot.github.io/pyftdi/installation.html

Installs the libusb-1.0 library on macOS using the Homebrew package manager, a prerequisite for PyFTDI.

```bash
brew install libusb
```

--------------------------------

### Install libusb on Debian/Ubuntu

Source: https://eblot.github.io/pyftdi/installation.html

Installs the libusb-1.0 library required by PyFTDI on Debian-based Linux distributions.

```bash
apt-get install libusb-1.0
```

--------------------------------

### Run PyFTDI I2C Tests

Source: https://eblot.github.io/pyftdi/api/i2c.html

Example of how to run I2C sample tests using PyFTDI. This involves setting environment variables for the FTDI device and log level, connecting I2C slaves, and executing the test script.

```bash
# optional: specify an alternative FTDI device
export FTDI_DEVICE=ftdi://ftdi:2232h/1
# optional: increase log level
export FTDI_LOGLEVEL=DEBUG
# be sure to connect the appropriate I2C slaves to the FTDI I2C bus and run
PYTHONPATH=. python3 pyftdi/tests/i2c.py
```

--------------------------------

### Add Custom Vendor/Product Names and Create Device URL

Source: https://eblot.github.io/pyftdi/installation.html

This example demonstrates how to register custom vendor and product names with PyFtdi, allowing device identification via descriptive strings instead of numerical IDs. It also shows creating FTDI device URLs using these custom names or numerical IDs. Requires 'pyftdi'.

```python
from pyftdi.ftdi import Ftdi

# Example with numerical IDs
Ftdi.add_custom_vendor(0x1234)
Ftdi.add_custom_product(0x1234, 0x5678)

# Example with string names
Ftdi.add_custom_vendor(0x1234, 'myvendor')
Ftdi.add_custom_product(0x1234, 0x5678, 'myproduct')

f1 = Ftdi.create_from_url('ftdi://0x1234:0x5678/1')
f2 = Ftdi.create_from_url('ftdi://myvendor:myproduct/2')
```

--------------------------------

### Add Custom Vendor and Product IDs to PyFtdi

Source: https://eblot.github.io/pyftdi/installation.html

This snippet shows how to configure PyFtdi to support FTDI devices with custom vendor and product IDs. The 'pyftdi' library must be installed. This setup should precede any FTDI device opening operations.

```python
from pyftdi.ftdi import Ftdi

# Replace 'vendor_id' and 'product_id' with actual 16-bit integer values
vendor_id = 0x1234
product_id = 0x5678

Ftdi.add_custom_vendor(vendor_id)
Ftdi.add_custom_product(vendor_id, product_id)
```

--------------------------------

### Install PyFTDI using pip

Source: https://eblot.github.io/pyftdi/installation.html

Installs the PyFTDI Python package and its dependencies using pip, the standard Python package installer.

```python
pip3 install pyftdi
```

--------------------------------

### List FTDI Devices with PyFtdi

Source: https://eblot.github.io/pyftdi/installation.html

This snippet demonstrates how to list all available FTDI devices connected to the host system using the PyFtdi library. It requires the 'pyftdi' package to be installed. The output will show the URLs for each detected device.

```python
from pyftdi.ftdi import Ftdi
Ftdi.show_devices()
```

--------------------------------

### GET /usb/devices

Source: https://eblot.github.io/pyftdi/api/usbtools.html

Retrieves a list of supported USB devices based on provided vendor and product maps.

```APIDOC
## GET /usb/devices

### Description
Show supported devices. When the joker url scheme://*/? is specified, it generates a list of connected USB devices that match supported hardware.

### Method
GET

### Endpoint
/usb/devices

### Parameters
#### Query Parameters
- **scheme** (str) - Required - Scheme to match in the URL string.
- **vdict** (Dict[str, int]) - Required - Vendor name map of USB vendor IDs.
- **pdict** (Dict[int, Dict[str, int]]) - Required - Vendor ID map of product name map of product IDs.
- **devdescs** (Sequence[Tuple[UsbDeviceDescriptor, int]]) - Required - Candidate devices.
- **out** (TextIO) - Optional - Output stream, defaults to stdout.

### Request Example
{
  "scheme": "ftdi://",
  "vdict": {"FTDI": 1027},
  "pdict": {1027: {"FT232R": 24577}},
  "devdescs": []
}

### Response
#### Success Response (200)
- **devices** (list) - A list of connected USB devices matching the criteria.
```

--------------------------------

### Get Device

Source: https://eblot.github.io/pyftdi/api/usbtools.html

Finds a previously opened device matching the descriptor or initializes a new one. Use index or serial for disambiguation if multiple devices of the same type are connected.

```APIDOC
## CLASS METHOD: UsbTools._get_device

### Description
Find a previously open device with the same vendor/product or initialize a new one, and return it.

### Note
If several FTDI devices of the same kind (vid, pid) are connected to the host, either the `index` or `serial` argument should be used to discriminate the FTDI device. The `index` argument is not a reliable solution as the host may enumerate the USB device in random order. The `serial` argument is a more reliable selector and should always be preferred. Some FTDI devices support several interfaces/ports (such as FT2232H, FT4232H and FT4232HA). The `interface` argument selects the FTDI port to use, starting from 1 (not 0).

### Method
`classmethod _get_device(_devdesc_)`

### Parameters
*   **devdesc** (`UsbDeviceDescriptor`) - Device descriptor that identifies the device by constraints.

### Returns
*   `Device` - A PyUSB device instance.
```

--------------------------------

### POST /gpio/open

Source: https://eblot.github.io/pyftdi/api/gpio.html

Initializes a connection to an FTDI device in bit-bang mode.

```APIDOC
## POST /gpio/open

### Description
Opens a new interface to the specified FTDI device in bitbang mode.

### Method
POST

### Endpoint
/gpio/open

### Parameters
#### Query Parameters
- **url** (str) - Required - A FTDI URL selector
- **direction** (int) - Optional - A bitfield specifying the FTDI GPIO direction (high=output, low=input)
- **initial** (int) - Optional - Initial GPIO output value
- **pace** (int) - Optional - Pace in GPIO sample per second

### Response
#### Success Response (200)
- **pace** (int) - Actual bitbang pace in samples per second
```

--------------------------------

### Initialize PyFtdi as a pyserial backend

Source: https://eblot.github.io/pyftdi/api/uart.html

Demonstrates how to import the serialext module and open a serial port connection using a specific FTDI device URL.

```python
import pyftdi.serialext

# Open a serial port on the second FTDI device interface (IF/2) @ 3Mbaud
port = pyftdi.serialext.serial_for_url('ftdi://ftdi:2232h/2', baudrate=3000000)

# Send bytes
port.write(b'Hello World')

# Receive bytes
data = port.read(1024)
```

--------------------------------

### Configure SPI Environment and Run Tests

Source: https://eblot.github.io/pyftdi/api/spi.html

Demonstrates how to set environment variables to specify an FTDI device and log level, followed by executing the built-in SPI test suite.

```bash
export FTDI_DEVICE=ftdi://ftdi:2232h/1
export FTDI_LOGLEVEL=DEBUG
PYTHONPATH=. python3 pyftdi/tests/spi.py
```

--------------------------------

### Initialize and Use SpiPort for SPI Communication

Source: https://eblot.github.io/pyftdi/api/spi.html

Demonstrates how to initialize an SpiController, configure it for a specific FTDI device, obtain an SPI port, set the communication frequency, and perform various data exchange operations including sending, receiving, and duplex exchanges. It also shows how to manage SPI transactions by controlling the chip select (CS) line.

```python
>>> ctrl = SpiController()
>>> ctrl.configure('ftdi://ftdi:232h/1')
>>> spi = ctrl.get_port(1)
>>> spi.set_frequency(1000000)
>>> # send 2 bytes
>>> spi.exchange([0x12, 0x34])
>>> # send 2 bytes, then receive 2 bytes
>>> out = spi.exchange([0x12, 0x34], 2)
>>> # send 2 bytes, then receive 4 bytes, manage the transaction
>>> out = spi.exchange([0x12, 0x34], 2, True, False)
>>> out.extend(spi.exchange([], 2, False, True))
```

--------------------------------

### Basic I2C Communication with PyFtdi

Source: https://eblot.github.io/pyftdi/api/i2c.html

Demonstrates how to instantiate an I2C controller, configure the FTDI interface, and perform basic read/write operations with an I2C slave device.

```python
from pyftdi.i2c import I2cController

# Instantiate an I2C controller
i2c = I2cController()

# Configure the first interface (IF/1) of the FTDI device as an I2C master
i2c.configure('ftdi://ftdi:2232h/1')

# Get a port to an I2C slave device
slave = i2c.get_port(0x21)

# Send one byte, then receive one byte
slave.exchange([0x04], 1)

# Write a register to the I2C slave
slave.write_to(0x06, b'\x00')

# Read a register from the I2C slave
slave.read_from(0x00, 1)
```

--------------------------------

### Configure and Run PyFtdi Serial Terminal

Source: https://eblot.github.io/pyftdi/api/uart.html

Commands to set up the environment using PYTHONPATH and execute the pyterm.py utility to list devices or initiate a serial session.

```bash
PYTHONPATH=$PWD pyftdi/bin/pyterm.py ftdi:///?
PYTHONPATH=. python3 pyftdi/bin/ftdi_urls.py
PYTHONPATH=$PWD pyftdi/bin/pyterm.py ftdi://ftdi:2232/1
```

--------------------------------

### GET /gpio/read

Source: https://eblot.github.io/pyftdi/gpio.html

Reads the current state of the GPIO pins.

```APIDOC
## GET /gpio/read

### Description
Reads the current state of the GPIO port.

### Method
GET

### Response
#### Success Response (200)
- **value** (integer) - The current state of the GPIO pins
```

--------------------------------

### GET /gpio/read

Source: https://eblot.github.io/pyftdi/api/gpio.html

Reads the electrical level of GPIO input pins.

```APIDOC
## GET /gpio/read

### Description
Reads the GPIO input pin electrical level using either peek mode or the HW FIFO.

### Method
GET

### Endpoint
/gpio/read

### Parameters
#### Query Parameters
- **readlen** (int) - Optional - Number of 8-bit samples to retrieve
- **peek** (bool) - Optional - Whether to sample instantaneous values or use HW FIFO
- **noflush** (bool) - Optional - Whether to disable RX buffer flush

### Response
#### Success Response (200)
- **data** (int/bytes) - 8-bit integer if peek mode is used, otherwise a bytes buffer
```

--------------------------------

### Dump FTDI EEPROM Configuration

Source: https://eblot.github.io/pyftdi/api/eeprom.html

Demonstrates how to instantiate an EEPROM manager, connect to a specific FTDI device via URL, and display both the parsed configuration and raw data.

```python
from pyftdi.eeprom import FtdiEeprom
from pyftdi.misc import hexdump

eeprom = FtdiEeprom()
eeprom.open('ftdi://ftdi:2232h/1')
eeprom.dump_config()
print(hexdump(eeprom.data))
```

--------------------------------

### List Devices by URL

Source: https://eblot.github.io/pyftdi/api/usbtools.html

Lists candidate devices that match a given device URL pattern. Use `show_devices()` to generate URLs from the candidates list.

```APIDOC
## CLASS METHOD: UsbTools._list_devices

### Description
List candidates that match the device URL pattern.

### See Also
`show_devices()` to generate the URLs from the candidates list.

### Method
`classmethod _list_devices(_urlstr_, _vdict_, _pdict_, _default_vendor_)`

### Parameters
*   **urlstr** - The URL string to parse.
*   **vdict** (`Dict[str, int]`) - A mapping from vendor names to USB vendor IDs.
*   **pdict** (`Dict[int, Dict[str, int]]`) - A mapping from vendor IDs to product name maps, which in turn map product names to product IDs.
*   **default_vendor** (`int`) - The default vendor ID to use if none is specified.

### Returns
*   `List[Tuple[UsbDeviceDescriptor, int]]` - A list of tuples, where each tuple contains a `UsbDeviceDescriptor` and the interface number.
```

--------------------------------

### Get String Descriptor

Source: https://eblot.github.io/pyftdi/api/usbtools.html

Retrieves a string descriptor from a USB device, handling potential PyUSB API changes.

```APIDOC
## CLASS METHOD: UsbTools._get_string

### Description
Retrieve a string from the USB device, dealing with PyUSB API breaks.

### Method
`classmethod _get_string(_device_, _stridx_)`

### Parameters
*   **device** (`Device`) - The USB device instance.
*   **stridx** (`int`) - The string identifier (index).

### Returns
*   `str` - The string read from the USB device.
```

--------------------------------

### Communicate with SPI Data Flash (Half-Duplex)

Source: https://eblot.github.io/pyftdi/api/spi.html

Demonstrates how to instantiate an SPI controller, configure the FTDI interface, and perform a half-duplex exchange to retrieve a JEDEC ID from a SPI slave.

```python
spi = SpiController()
spi.configure('ftdi://ftdi:2232h/1')
slave = spi.get_port(cs=0, freq=12E6, mode=0)
jedec_id = slave.exchange([0x9f], 3)
```

--------------------------------

### Get Modem Status (Python)

Source: https://eblot.github.io/pyftdi/api/ftdi.html

This method retrieves the current modem status of the FTDI device as a tuple of set signals. The signals are returned as decoded short strings.

```python
modem_status() -> Tuple[str, ...]
```

--------------------------------

### Perform Non-Byte Aligned SPI Transfers

Source: https://eblot.github.io/pyftdi/api/spi.html

Provides examples of handling non-byte aligned SPI transfers using the 'droptail' parameter to control bit-level read and write operations.

```python
spi = SpiController()
spi.configure('ftdi://::/1')
slave = spi.get_port(cs=0)
slave.write(b'\xff', droptail=2)
slave.read(2, droptail=3)
```

--------------------------------

### Build Device Strings

Source: https://eblot.github.io/pyftdi/api/usbtools.html

Constructs URLs and device descriptors from a list of USB device descriptors.

```APIDOC
## CLASS METHOD: UsbTools._build_dev_strings

### Description
Build URL and device descriptors from UsbDeviceDescriptors.

### Method
`classmethod _build_dev_strings(_scheme_, _vdict_, _pdict_, _devdescs_)`

### Parameters
*   **scheme** (`str`) - The protocol part of the URLs to generate.
*   **vdict** (`Dict[str, int]`) - A mapping from vendor names to USB vendor IDs.
*   **pdict** (`Dict[int, Dict[str, int]]`) - A mapping from vendor IDs to product name maps, which in turn map product names to product IDs.
*   **devdescs** (`Sequence[Tuple[UsbDeviceDescriptor, int]]`) - A sequence of tuples, where each tuple contains a `UsbDeviceDescriptor` and an interface number.

### Returns
*   `List[Tuple[str, str]]` - A list of tuples, where each tuple contains a generated URL and its corresponding device descriptor string.
```

--------------------------------

### Get Maximum EEPROM Size (Python)

Source: https://eblot.github.io/pyftdi/api/ftdi.html

This property reports the maximum size of the EEPROM for an FTDI device. The actual size might be smaller or zero if no EEPROM is connected or supported. It returns the size in bytes.

```python
max_eeprom_size: int
```

--------------------------------

### Open FTDI Device Interface via URL

Source: https://eblot.github.io/pyftdi/api/ftdi.html

Initializes a connection to an FTDI device using a URL selector. This is the standard method for establishing communication with a specific device.

```python
from pyftdi.ftdi import Ftdi

ftdi = Ftdi()
ftdi.open_from_url('ftdi://ftdi:232:A1000000/1')
```

--------------------------------

### Create FTDI Instance from URL (Python)

Source: https://eblot.github.io/pyftdi/api/ftdi.html

Creates an Ftdi instance from a URL. The URL format is 'ftdi://[vendor[:product[:index|:serial]]]/interface'. This method simplifies the process of initializing an FTDI device connection using a descriptive URL.

```python
classmethod _create_from_url(_url_)
    
    Create an Ftdi instance from an URL
URL scheme: ftdi://[vendor[:product[:index|:serial]]]/interface 

    Parameters:
        
      **url** (`str`) – FTDI device selector 

    Return type:
        
      `Ftdi` 

    Returns:
        
      a fresh, open Ftdi instance 

```

--------------------------------

### Read Data from SPI Slave

Source: https://eblot.github.io/pyftdi/api/spi.html

Reads a specified number of bytes from the SPI slave. This method can be used independently for reading or as part of a larger transaction. It supports controlling the start and stop of the SPI transaction and handling partial byte reads.

```python
spi.read(_readlen =0_, _start =True_, _stop =True_, _droptail =0_)
```

--------------------------------

### Add Custom Product ID to PyFtdi

Source: https://eblot.github.io/pyftdi/installation.html

This code allows PyFtdi to recognize FTDI devices with a custom product ID, in conjunction with the official FTDI vendor ID. Ensure 'pyftdi' is installed. This configuration must be done before opening any FTDI device.

```python
from pyftdi.ftdi import Ftdi

# Replace 'product_id' with the actual 16-bit integer value
product_id = 0xXXXX
Ftdi.add_custom_product(Ftdi.DEFAULT_VENDOR, product_id)
```

--------------------------------

### Configure I2C Controller and Access GPIO

Source: https://eblot.github.io/pyftdi/api/i2c.html

Demonstrates how to initialize an I2cController with a specific FTDI URL and retrieve the associated GPIO port for pin management. The controller handles the I2C bus configuration, while the GPIO port allows for bitfield-based pin control.

```python
from pyftdi.i2c import I2cController

# Initialize controller
i2c = I2cController()
i2c.configure('ftdi://ftdi:232h/1', frequency=100000)

# Access GPIO port
gpio = i2c.get_gpio()

# Set pin direction and write value
gpio.set_direction(0x08, 0x08) # Set bit 3 as output
gpio.write(0x08) # Set bit 3 high

# Close connection
i2c.close()
```

--------------------------------

### Perform SPI Data Exchange

Source: https://eblot.github.io/pyftdi/api/spi.html

Executes a data exchange transaction with an SPI slave. This method can send data, receive data, or perform both simultaneously (duplex). It provides fine-grained control over transaction start, stop, and data handling, including managing non-byte-sized accesses.

```python
spi.exchange(_out =b''_, _readlen =0_, _start =True_, _stop =True_, _duplex =False_, _droptail =0_)
```

--------------------------------

### GPIO API Overview

Source: https://eblot.github.io/pyftdi/api/gpio.html

Documentation for the GPIO interface provided by PyFtdi for direct pin manipulation.

```APIDOC
## GPIO API

### Description
The GPIO API allows for direct drive of GPIO pins on an FTDI device. This mode is mutually exclusive with advanced serial MPSSE features like I2C, SPI, or JTAG.

### Usage Note
If you require both GPIO and MPSSE functionality on the same port, please use the dedicated shared mode APIs provided within the SPI or I2C modules.

### Limitations
- This API does not provide access to the special CBUS port of FT232R, FT232H, FT230X, and FT231X devices.
- Refer to the 'CBUS GPIOs' documentation for specific CBUS pin control.

### Quickstart
Refer to the provided library example at `tests/gpio.py` for implementation details.
```

--------------------------------

### GPIO Controller Overview

Source: https://eblot.github.io/pyftdi/gpio.html

Overview of GPIO access methods in PyFtdi, including GpioController, SpiGpioPort, and I2cGpioPort.

```APIDOC
## GPIOs

### Overview

PyFtdi offers direct access to the IO pins of FTDI devices through several APIs:

*   `GpioController` (implemented as `GpioAsyncController`, `GpioSyncController`, and `GpioMpsseController`) provides full access to FTDI pins as raw I/O pins.
*   `SpiGpioPort` provides access to all free pins of an FTDI interface not reserved for SPI.
*   `I2cGpioPort` provides access to all free pins of an FTDI interface not reserved for I2C.

### Other Modes

*   GPIO raw access is not supported with the JTAG feature.
*   GPIO cannot be used simultaneously with UART mode on the same interface. Limited GPIO access is available through UART mode.

This document covers common definitions and usage for these GPIO APIs.
```

--------------------------------

### Enumerate and Identify Devices

Source: https://eblot.github.io/pyftdi/api/ftdi.html

Static methods to discover connected FTDI devices based on vendor/product IDs or to parse device URLs for identification without opening a full connection.

```python
devices = Ftdi.find_all([(0x0403, 0x6010)])
info = Ftdi.get_identifiers("ftdi://ftdi:232:A50285BI/1")
```

--------------------------------

### Perform I2C Data Exchange with PyFtdi

Source: https://eblot.github.io/pyftdi/api/i2c.html

Demonstrates how to configure an I2C controller, obtain a port for a specific slave address, and perform write and exchange operations.

```python
ctrl = I2cController()
ctrl.configure('ftdi://ftdi:232h/1')
i2c = ctrl.get_port(0x21)
# send 2 bytes
i2c.write([0x12, 0x34])
# send 2 bytes, then receive 2 bytes
out = i2c.exchange([0x12, 0x34], 2)
```

--------------------------------

### Open FTDI Device Connection (Python)

Source: https://eblot.github.io/pyftdi/api/ftdi.html

This method opens a new interface to a specified FTDI device. It requires vendor and product IDs and can use optional arguments like bus, address, index, serial number, or interface number to select the device. It's crucial to use the serial argument for reliable selection when multiple devices are present.

```python
open(_vendor_, _product_, _bus=None_, _address=None_, _index=0_, _serial=None_, _interface=1_)
```

--------------------------------

### Configure GPIO Pin Direction

Source: https://eblot.github.io/pyftdi/gpio.html

Demonstrates how to initialize a GPIO controller and set the direction of pins using a bitmask. The direction value is calculated by setting output pins to 1 and input pins to 0.

```python
gpio = GpioAsyncController()
gpio.configure('ftdi:///1', direction=0x76)
# later, reconfigure BD2 as input and BD7 as output
gpio.set_direction(0x84, 0x80)
```

--------------------------------

### POST /eeprom/load_config

Source: https://eblot.github.io/pyftdi/api/eeprom.html

Loads EEPROM configuration from an INI file stream, allowing for raw data or human-readable value updates.

```APIDOC
## POST /eeprom/load_config

### Description
Loads configuration settings from an INI file. Supports loading raw hex data, human-readable values, or a combination of both.

### Method
POST

### Endpoint
/eeprom/load_config

### Parameters
#### Request Body
- **file** (string) - Required - The path or content of the INI file.
- **section** (string) - Optional - The section to load: 'raw', 'values', or 'all' (default).

### Request Example
{
  "file": "config.ini",
  "section": "all"
}

### Response
#### Success Response (200)
- **status** (string) - Confirmation of successful load.
```

--------------------------------

### POST /gpio/configure

Source: https://eblot.github.io/pyftdi/gpio.html

Configures the GPIO port direction for an AsyncController instance.

```APIDOC
## POST /gpio/configure

### Description
Configures the GPIO port direction. The direction is defined as a bitmask where 1 is output and 0 is input.

### Method
POST

### Parameters
#### Request Body
- **url** (string) - Required - The FTDI device URL (e.g., 'ftdi:///1')
- **direction** (integer) - Required - Hexadecimal bitmask representing pin directions

### Request Example
{
  "url": "ftdi:///1",
  "direction": 0x76
}

### Response
#### Success Response (200)
- **status** (string) - Configuration success status
```

--------------------------------

### POST /usb/release

Source: https://eblot.github.io/pyftdi/api/usbtools.html

Releases a previously opened USB device instance to free up resources.

```APIDOC
## POST /usb/release

### Description
Releases a previously open device if it is no longer in use.

### Method
POST

### Endpoint
/usb/release

### Parameters
#### Request Body
- **usb_dev** (Device) - Required - A previously instantiated USB device instance.

### Request Example
{
  "usb_dev": "<DeviceInstance>"
}

### Response
#### Success Response (200)
- **status** (string) - Confirmation that the device was released.
```

--------------------------------

### Interface and Port Definitions

Source: https://eblot.github.io/pyftdi/gpio.html

Explanation of FTDI interfaces and ports as used in PyFtdi.

```APIDOC
## Definitions

### Interfaces

An FTDI interface is a hardware communication port on an FTDI device. Each interface can be configured independently. Multiple interfaces on the same device can be accessed concurrently, but the same interface cannot be accessed by multiple applications simultaneously.

**Warning:** A USB device reset affects all interfaces on an FTDI device. PyFtdi does not automatically reset a device upon interface initialization to avoid this.

### Ports

In PyFtdi, a 'port' is generally synonymous with an 'interface'. While FTDI datasheets might distinguish between multiple ports within a single interface (e.g., A*BUS, B*BUS), PyFtdi APIs treat them as a single unit. Each port/interface can be accessed as raw input/output pins. A pin must be configured as either input or output before use.

The width (number of pins) of a port varies by FTDI model:

*   FT232R: 8-bit (DBUS)
*   FT232H: 16-bit (ADBUS/ACBUS)
*   FT2232D: Two 12-bit ports (ADBUS/ACBUS and BDBUS/BCBUS)
*   FT2232H: Two 16-bit ports (ADBUS/ACBUS and BDBUS/BCBUS)
*   FT4232H/FT4232HA: Four 8-bit ports (ADBUS, BDBUS, CDBUS, DDBUS)
*   FT230X: 4-bit
*   FT231X: 8-bit

Legacy terms like 'wide' and 'narrow' ports are deprecated; use the port `width` property instead.
```

--------------------------------

### GpioMpsseController API

Source: https://eblot.github.io/pyftdi/api/gpio.html

API documentation for the GpioMpsseController, which handles GPIO operations in MPSSE mode.

```APIDOC
## GpioMpsseController

### Description
GPIO controller for an FTDI port, in MPSSE mode. All GPIO pins are reachable, but MPSSE mode is slower than other modes. Beware that LSBs (b0..b7) and MSBs (b8..b15) are accessed with two subsequence commands, so a slight delay may occur when sampling or changing both groups at once. In other words, it is not possible to atomically read to / write from LSBs and MSBs. This might be worth checking the board design if atomic access to several lines is required.

### Methods

#### read

Read the GPIO input pin electrical level.

**Parameters:**
- **readlen** (int) - How many GPIO samples to retrieve. Each sample is `width()` bit wide.
- **peek** (Optional[bool]) - Whether to peek current value from port, or to use MPSSE stream and HW FIFO. When peek mode is selected, readlen should be 1. It is not available with wide ports if some of the MSB pins are configured as input.

**Returns:**
- Union[int, bytes, Tuple[int]] - A `width()` bit wide integer if direct mode is used, a bytes buffer if `width()` is a byte, a list of integers otherwise (MPSSE mode only).

#### set_frequency

Set the frequency at which sequence of GPIO samples are read and written.

**Parameters:**
- **frequency** (Union[int, float]) - The new frequency, in GPIO samples per second

**Returns:**
- None

#### write

Set the GPIO output pin electrical level, or output a sequence of bytes @ constant frequency to GPIO output pins.

**Parameters:**
- **out** (Union[bytes, bytearray, Iterable[int], int]) - A bitfield of GPIO pins, or a sequence of them

**Returns:**
- None

```

--------------------------------

### Enumerate Candidate Devices

Source: https://eblot.github.io/pyftdi/api/usbtools.html

Enumerates USB device URLs that match a partial URL and vendor/product ID criteria.

```APIDOC
## CLASS METHOD: UsbTools._enumerate_candidates

### Description
Enumerate USB device URLs that match partial URL and VID/PID criteria.

### Method
`classmethod _enumerate_candidates(_urlpart_, _vdict_, _pdict_, _default_vendor_)`

### Parameters
*   **urlpart** - The splitted device specifier URL.
*   **vdict** (`Dict[str, int]`) - A mapping from vendor names to USB vendor IDs.
*   **pdict** (`Dict[int, Dict[str, int]]`) - A mapping from vendor IDs to product name maps, which in turn map product names to product IDs.
*   **default_vendor** (`int`) - The default vendor ID to use if none is specified.

### Returns
*   `Tuple[List[Tuple[UsbDeviceDescriptor, int]], Optional[int]]` - A tuple containing a list of matching USB devices (UsbDeviceDescriptor, interface count) and an optional parsed index.
```

--------------------------------

### Open FTDI Serial Connection and Access Object

Source: https://eblot.github.io/pyftdi/gpio.html

Demonstrates how to establish a serial connection to an FTDI device and access its underlying FTDI object for further manipulation. This is useful for directly interacting with device properties like 'has_cbus'.

```python
port = serial_for_url('ftdi:///1')
ftdi = port.ftdi
print(ftdi.has_cbus)
```

--------------------------------

### Manage SPI and GPIO Concurrently

Source: https://eblot.github.io/pyftdi/api/spi.html

Illustrates how to use the SPI controller to manage both SPI communication and extra GPIO pins for control signals.

```python
spi = SpiController()
spi.configure('ftdi://::/1')
slave = spi.get_port(cs=0, freq=12E6, mode=0)
gpio = spi.get_gpio()
gpio.set_direction(0x30, 0x10)
gpio.write(0x10)
slave.write(b'hello world!')
gpio.write(0x00)
pin = bool(gpio.read() & 0x20)
```

--------------------------------

### Find Backend

Source: https://eblot.github.io/pyftdi/api/usbtools.html

Attempts to find and load a PyUSB backend. This method is typically not needed for regular usage.

```APIDOC
## CLASS METHOD: UsbTools._find_backend

### Description
Try to find and load an PyUSB backend.

### Note
There is no need to call this method for regular usage.

### Method
`classmethod _find_backend()`

### Returns
*   `IBackend` - The PyUSB backend instance.
```

--------------------------------

### Open FTDI Device in Bitbang Mode from URL (Python)

Source: https://eblot.github.io/pyftdi/api/ftdi.html

This method opens an FTDI device in bitbang mode using a URL. It supports configuration of direction, latency, baudrate, and sync mode. This function is useful for opening devices based on a URL pattern.

```python
open_bitbang_from_url(_url_, _direction=0_, _latency=16_, _baudrate=1000000_, _sync=False_)
```

--------------------------------

### Write GPIO Pin States

Source: https://eblot.github.io/pyftdi/gpio.html

Shows how to write values to GPIO output pins. Note that writing to pins configured as input will trigger an IOError.

```python
gpio = GpioAsyncController()
gpio.configure('ftdi:///1', direction=0x76)
# all output set low
gpio.write(0x00)
# all output set high
gpio.write(0x76)
# all output set high, apply direction mask
gpio.write(0xFF & gpio.direction)
# all output forced to high, writing to input pins is illegal
gpio.write(0xFF)  # raises an IOError
gpio.close()
```
Tokens:
Raw