Ft6x06 Rs

https://docs.rs/ft6x06-rs/latest
Admin
A pure-Rust `embedded-hal`-based driver for the I2C-based `ft6x06` capacitive touch screen...
Tokens:54,245
Snippets:482
Trust Score:9.7
Update:9 months ago
Show doc for...
Tokens:
Raw
### Control Mode API

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/sync.rs_search=u32+-%3E+bool

APIs for getting and setting the device's control mode.

```APIDOC
## Get Control Mode

### Description
Gets the current operating mode of the FT6x06 device.

### Method
`get_control_mode`

### Endpoint
Reads from the `CTRL` register (0x00).

### Parameters
None

### Request Example
```rust
let mode = ft6x06.get_control_mode()?;
```

### Response
#### Success Response (200)
- **ControlMode** - The current control mode of the device.

## Set Control Mode

### Description
Sets the operating mode of the FT6x06 device.

### Method
`set_control_mode`

### Endpoint
Writes to the `CTRL` register (0x00).

### Parameters
- **mode** (ControlMode) - The desired control mode to set.

### Request Example
```rust
ft6x06.set_control_mode(ControlMode::Active)?;
```

### Response
#### Success Response (200)
- **()** - Indicates successful operation.
```

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

### Get Control Mode

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=u32+-%3E+bool

Gets the current operating mode of the FT6x06 device.

```APIDOC
## Get Control Mode

### Description
Gets the current operating mode of the FT6x06 device. This corresponds to the `CTRL` register.

### Method
`get_control_mode`

### Endpoint
N/A (Method call)

### Parameters
None

### Request Example
```rust
match ft6x06.get_control_mode().await {
    Ok(mode) => {
        println!("Current mode: {:?}", mode);
    }
    Err(e) => {
        // Handle error
    }
}
```

### Response
#### Success Response (200)
- **Result<ControlMode, DriverError<I2C::Error>>** - A `Result` containing the current `ControlMode` or a `DriverError`.

#### Response Example
```json
"Active"
```
```

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

### Get Touch Event

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=u32+-%3E+bool

Retrieves the latest touch event with all available data and touch points from the device.

```APIDOC
## Get Touch Event

### Description
Retrieves the latest touch event with all available data and touch points from the device.

### Method
`get_touch_event`

### Endpoint
N/A (Method call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
match ft6x06.get_touch_event().await {
    Ok(Some(touch_event)) => {
        // Process touch event
    }
    Ok(None) => {
        // No touch event data available
    }
    Err(e) => {
        // Handle error
    }
}
```

### Response
#### Success Response (200)
- **Result<Option<TouchEvent>, DriverError<I2C::Error>>** - A `Result` containing an `Option<TouchEvent>` if successful, or a `DriverError` if an error occurred.

#### Response Example
```json
{
  "gesture_id": 0,
  "points": [
    {
      "x": 100,
      "y": 200,
      "id": 0
    }
  ]
}
```
```

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

### Report Rates API

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/sync.rs_search=u32+-%3E+bool

APIs for getting and setting the report rates for active and monitor modes.

```APIDOC
## Get Report Rates

### Description
Gets the configured report rates (scan rates) for active and monitor modes.

### Method
`get_report_rates`

### Endpoint
Reads from `PERIODACTIVE` (0x05) and `PERIODMONITOR` (0x06) registers.

### Parameters
None

### Request Example
```rust
let (active_rate, monitor_rate) = ft6x06.get_report_rates()?;
```

### Response
#### Success Response (200)
- **(u8, u8)** - A tuple containing the active report rate and the monitor report rate.

## Set Report Rates

### Description
Sets the report rates (scan rates) for active and monitor modes.

### Method
`set_report_rates`

### Endpoint
Writes to `PERIODACTIVE` (0x05) and `PERIODMONITOR` (0x06) registers.

### Parameters
- **active_rate** (u8) - The desired report rate for active mode.
- **monitor_rate** (u8) - The desired report rate for monitor mode.

### Request Example
```rust
ft6x06.set_report_rates(60, 25)?;
```

### Response
#### Success Response (200)
- **()** - Indicates successful operation.
```

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

### FT6x06Async Control Mode

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs

Methods for getting and setting the control mode of the FT6x06 device.

```APIDOC
## Control Mode Management

### `get_control_mode(&mut self) -> Result<ControlMode, DriverError<I2C::Error>>`

Gets the current control mode of the device. This corresponds to the `CTRL` register.

Returns `Ok(ControlMode)` representing the current mode, or `Err(DriverError)` if an error occurs.

### `set_control_mode(&mut self, mode: ControlMode) -> Result<(), DriverError<I2C::Error>>`

Sets the device control mode. The default control mode is [`ControlMode::MonitorIdle`]. This corresponds to the `CTRL` register.

- **mode** (ControlMode) - The desired control mode to set.

Returns `Ok(())` on success, or `Err(DriverError)` if an error occurs.

### Request Example (Set Control Mode)
```rust
let mut ft6x06 = FT6x06Async::new(i2c);
match ft6x06.set_control_mode(ControlMode::MonitorActive).await {
    Ok(_) => println!("Control mode set to MonitorActive."),
    Err(e) => eprintln!("Error setting control mode: {:?}", e),
}
```

### Response Example (Get Control Mode)
```json
{
  "ControlMode": "MonitorActive"
}
```
```

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

### Get Report Rates

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=u32+-%3E+bool

Retrieves the configured report rates (scan rates) for both active and monitor modes.

```APIDOC
## Get Report Rates

### Description
Gets the configured report rates for each mode. This corresponds to the `PERIODACTIVE` and `PERIODMONITOR` registers.

### Method
`get_report_rates`

### Endpoint
N/A (Method call)

### Parameters
None

### Request Example
```rust
match ft6x06.get_report_rates().await {
    Ok((active_rate, monitor_rate)) => {
        println!("Active rate: {}, Monitor rate: {}", active_rate, monitor_rate);
    }
    Err(e) => {
        // Handle error
    }
}
```

### Response
#### Success Response (200)
- **Result<(u8, u8), DriverError<I2C::Error>>** - A `Result` containing a tuple of `(active_rate, monitor_rate)` or a `DriverError`.

#### Response Example
```json
[60, 25]
```
```

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

### Get Latest Touch Event Data (Async)

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=std%3A%3Avec

Asynchronously retrieves the latest touch event data from the FT6x06 device. This involves reading a block of data from the I2C interface, starting from the GEST_ID_ADDR. The function parses this data into a `TouchEvent` enum. It returns `None` if no touch event data is available or if the data is invalid.

```rust
pub async fn get_touch_event(&mut self) -> Result<Option<TouchEvent>, DriverError<I2C::Error>> {
    // Read from 0x01 to 0x0E for GEST_ID, TD_STATUS, and PX_X registers.
    let mut buf = [0u8; 14];
    self.i2c
        .write_read(I2C_ADDR, &[GEST_ID_ADDR], &mut buf)
        .await?;
    Ok(common::touch_event_from_buf(&buf))
}
```

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

### Get Report Rates (Async)

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=

Reads the report rates for both active and monitor modes from the `PERIODACTIVE` and `PERIODMONITOR` registers. Returns a tuple containing the active rate and monitor rate.

```rust
pub async fn get_report_rates(&mut self) -> Result<(u8, u8), DriverError<I2C::Error>> {
    let mut buf = [0u8; 2];
    self.i2c
        .write_read(I2C_ADDR, &[PERIOD_ACTIVE_ADDR], &mut buf)
        .await?;
    Ok((buf[0], buf[1]))
}
```

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

### Wait for Touch Event with Async FT6x06 Driver (Rust)

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/index

Illustrates how to use the asynchronous FT6x06 driver to wait for touch events. This example requires an I2C peripheral and an input pin for interrupt handling. It continuously waits for and logs touch events.

```Rust
// In the async driver, you can wait for the next touch event:
let mut irq_pin = Input::new(my_periph.GPIO_XX, Pull::Up);
let mut dev_async = FT6x06Async::new(i2c);

loop {
    let touch_event = dev_async.wait_for_touch(&mut irq_pin).await?;
    info!("{:?}", touch_event);
}
```

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

### GET /registers/{reg}

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=std%3A%3Avec

Reads a single byte from the specified device register. This serves as a general-purpose read function.

```APIDOC
## GET /registers/{reg}

### Description
Reads a single byte from the specified device register. This is a catch-all for reading from any register.

### Method
GET

### Endpoint
/registers/{reg}

### Parameters
#### Path Parameters
- **reg** (u8) - Required - The address of the register to read from.

### Response
#### Success Response (200)
- **value** (u8) - The byte read from the register.

#### Response Example
```json
{
  "value": 123
}
```
```

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

### Get Device Control Mode (Rust)

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06Async_search=u32+-%3E+bool

Asynchronously reads the current control mode of the FT6x06 device from the CTRL register. This indicates the operational state of the device.

```rust
pub async fn get_control_mode( &mut self, ) -> Result<ControlMode, DriverError<I2C::Error>>
```

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

### Get Control Mode (Async)

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=

Reads the current operational mode of the FT6x06 device from the `CTRL` register. It returns a `ControlMode` enum variant representing the device's state. An error is returned if the read value is not a valid `ControlMode`.

```rust
pub async fn get_control_mode(&mut self) -> Result<ControlMode, DriverError<I2C::Error>> {
    let mut buf = [0u8; 1];
    self.i2c
        .write_read(I2C_ADDR, &[CTRL_ADDR], &mut buf)
        .await?;

    let value = ControlMode::try_from(buf[0]).map_err(|()| DriverError::InvalidResponse)?;
    Ok(value)
}
```

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

### Get Latest Touch Event (Async)

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=

Retrieves the most recent touch event data from the FT6x06 device. It reads data from specific registers (0x01 to 0x0E) via I2C to extract gesture ID, touch status, and coordinates. Returns `None` if no touch event data is available.

```rust
pub async fn get_touch_event(&mut self) -> Result<Option<TouchEvent>, DriverError<I2C::Error>> {
    let mut buf = [0u8; 14];
    self.i2c
        .write_read(I2C_ADDR, &[GEST_ID_ADDR], &mut buf)
        .await?;
    Ok(common::touch_event_from_buf(&buf))
}
```

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

### Initialize and Configure FT6x06 Touch Screen (Rust)

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs_search=

Demonstrates the initialization and configuration of the FT6x06 touch screen controller using the synchronous driver. It sets interrupt modes, control modes, timeouts, and report rates, then reads these configurations back. This snippet requires the `sync-driver` feature.

```Rust
use ft6x06_rs::{FT6X06, ControlMode, InterruptMode};
use embedded_hal::blocking::i2c::I2C;

// Assuming 'i2c' is a valid I2C peripheral implementing embedded_hal::blocking::i2c::I2C
// let mut dev = FT6X06::new(i2c);

// Configure the device.
// dev.set_interrupt_mode(InterruptMode::Trigger)?;
// dev.set_control_mode(ControlMode::MonitorIdle)?;
// dev.set_active_idle_timeout(10)?;
// dev.set_report_rates(60, 25)?;

// Read the device configuration.
// let interrupt_mode = dev.get_interrupt_mode()?;
// let control_mode = dev.get_control_mode()?;
// let active_idle_timeout = dev.get_active_idle_timeout()?;
// let (active_rate, monitor_rate) = dev.get_report_rates()?;

// info!("Irq Mode: {}", interrupt_mode);
// info!("Ctrl Mode: {}", control_mode);
// info!("Active Idle Timeout: {}", active_idle_timeout);
// info!("Active Rate: {}", active_rate);
// info!("Monitor Rate: {}", monitor_rate);

// Get the latest touch data.
// let touch_event = dev.get_touch_event()?;
```

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

### FT6x06Async Initialization and Basic Operations (Rust)

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=u32+-%3E+bool

Initializes the FT6x06 asynchronous driver and provides methods for core functionalities like waiting for touch events, retrieving touch data, and managing device control modes. It depends on the `embedded-hal-async` crate for I2C communication and interrupt handling.

```Rust
use embedded_hal_async::{
    digital::Wait,
    i2c::I2c,
};

use crate::{
    common::{CTRL_ADDR, GEST_ID_ADDR, G_MODE_ADDR, I2C_ADDR, PERIOD_ACTIVE_ADDR, TIME_ENTER_MONITOR_ADDR},
    ControlMode, DriverError, InterruptMode, TouchEvent
};

/// An FT6x06 device.
///
/// This struct contains the full async interface to the FT6x06 device.
/// Certain features depend upon the specific FT6x06 chip and firmware version and some data or functionality may be unavailable.
pub struct FT6x06Async<I2C> {
    i2c: I2C,
}

impl<I2C: I2c<SevenBitAddress>> FT6x06Async<I2C> {
    pub fn new(i2c: I2C) -> Self {
        Self { i2c }
    }

    /// Wait for the next touch event interrupt from the specified irq pin.
    pub async fn wait_for_touch<P: Wait>(
        &mut self,
        irq: &mut P,
    ) -> Result<Option<TouchEvent>, DriverError<I2C::Error>> {
        irq.wait_for_falling_edge()
            .await
            .map_err(|_| DriverError::IrqError)?;

        self.get_touch_event().await
    }

    /// Retrieve the latest touch event with all available data and touch points.
    pub async fn get_touch_event(&mut self) -> Result<Option<TouchEvent>, DriverError<I2C::Error>> {
        // Read from 0x01 to 0x0E for GEST_ID, TD_STATUS, and PX_X registers.
        let mut buf = [0u8; 14];
        self.i2c
            .write_read(I2C_ADDR, &[GEST_ID_ADDR], &mut buf)
            .await?;
        Ok(common::touch_event_from_buf(&buf))
    }

    /// Get the current mode of the device.
    /// This corresponds to the `CTRL` register.
    pub async fn get_control_mode(&mut self) -> Result<ControlMode, DriverError<I2C::Error>> {
        let mut buf = [0u8; 1];
        self.i2c
            .write_read(I2C_ADDR, &[CTRL_ADDR], &mut buf)
            .await?;

        let value = ControlMode::try_from(buf[0]).map_err(|()| DriverError::InvalidResponse)?;
        Ok(value)
    }

    /// Set the device mode.
    /// The default control mode is [`ControlMode::MonitorIdle`].
    /// This corresponds to the `CTRL` register.
    pub async fn set_control_mode(
        &mut self,
        mode: ControlMode,
    ) -> Result<(), DriverError<I2C::Error>> {
        Ok(self.i2c.write(I2C_ADDR, &[CTRL_ADDR, mode as u8]).await?)
    }
}
```

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

### FT6x06Async Interrupt Mode

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs

Methods for getting the current interrupt mode of the device.

```APIDOC
## Interrupt Mode Management

### `get_interrupt_mode(&mut self) -> Result<InterruptMode, DriverError<I2C::Error>>`

Gets the current interrupt mode of the device. This corresponds to the `G_MODE` register.

Returns `Ok(InterruptMode)` representing the current interrupt mode, or `Err(DriverError)` if an error occurs.

### Request Example
```rust
let mut ft6x06 = FT6x06Async::new(i2c);
match ft6x06.get_interrupt_mode().await {
    Ok(mode) => println!("Current interrupt mode: {:?}", mode),
    Err(e) => eprintln!("Error getting interrupt mode: {:?}", e),
}
```

### Response Example
```json
{
  "InterruptMode": "InterruptPulse"
}
```
```

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

### FT6x06 Device Initialization and Basic Operations

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This section covers the initialization of the FT6x06 device and fundamental operations like retrieving touch events and managing control modes.

```APIDOC
## FT6x06 Device API

### Description
Provides methods for interacting with the FT6x06 touch controller.

### Methods

#### `new(i2c: I2C) -> Self`

*   **Description**: Creates a new FT6x06 device instance.
*   **Parameters**:
    *   `i2c` (I2C): An I2C peripheral compatible with `SevenBitAddress`.
*   **Returns**: An instance of `FT6x06`.

#### `get_touch_event(&mut self) -> Result<Option<TouchEvent>, DriverError<I2C::Error>>`

*   **Description**: Retrieves the latest touch event data, including all available touch points.
*   **Returns**: A `Result` containing an `Option<TouchEvent>` on success, or a `DriverError` on failure.

#### `get_control_mode(&mut self) -> Result<ControlMode, DriverError<I2C::Error>>`

*   **Description**: Gets the current control mode of the device (corresponds to the `CTRL` register).
*   **Returns**: A `Result` containing the `ControlMode` on success, or a `DriverError` on failure.

#### `set_control_mode(&mut self, mode: ControlMode) -> Result<(), DriverError<I2C::Error>>`

*   **Description**: Sets the device's control mode. The default is `ControlMode::MonitorIdle` (corresponds to the `CTRL` register).
*   **Parameters**:
    *   `mode` (ControlMode): The desired control mode to set.
*   **Returns**: A `Result` indicating success or a `DriverError` on failure.

#### `get_active_idle_timeout(&mut self) -> Result<u8, DriverError<I2C::Error>>`

*   **Description**: Retrieves the idle timeout value for `ControlMode::MonitorIdle` (corresponds to the `TIMEENTERMONITOR` register).
*   **Returns**: A `Result` containing the timeout value (u8) on success, or a `DriverError` on failure.

#### `set_active_idle_timeout(&mut self, timeout: u8) -> Result<(), DriverError<I2C::Error>>`

*   **Description**: Sets the idle timeout for `ControlMode::MonitorIdle`. The default is 10. (corresponds to the `TIMEENTERMONITOR` register).
*   **Parameters**:
    *   `timeout` (u8): The desired idle timeout value.
*   **Returns**: A `Result` indicating success or a `DriverError` on failure.

#### `get_report_rates(&mut self) -> Result<(u8, u8), DriverError<I2C::Error>>`

*   **Description**: Gets the configured report rates for active and monitor modes (corresponds to `PERIODACTIVE` and `PERIODMONITOR` registers).
*   **Returns**: A `Result` containing a tuple of (active_rate, monitor_rate) on success, or a `DriverError` on failure.

#### `set_report_rates(&mut self, active_rate: u8, monitor_rate: u8) -> Result<(), DriverError<I2C::Error>>`

*   **Description**: Sets the report rates (scan rates) for active and monitor modes. Defaults are 60hz (active) and 25hz (monitor) (corresponds to `PERIODACTIVE` and `PERIODMONITOR` registers).
*   **Parameters**:
    *   `active_rate` (u8): The report rate for active mode.
    *   `monitor_rate` (u8): The report rate for monitor mode.
*   **Returns**: A `Result` indicating success or a `DriverError` on failure.

#### `get_interrupt_mode(&mut self) -> Result<InterruptMode, DriverError<I2C::Error>>`

*   **Description**: Gets the current interrupt mode (corresponds to the `G_MODE` register).
*   **Returns**: A `Result` containing the `InterruptMode` on success, or a `DriverError` on failure.

#### `set_interrupt_mode(&mut self, mode: InterruptMode) -> Result<(), DriverError<I2C::Error>>`

*   **Description**: Sets the current interrupt mode (corresponds to the `G_MODE` register).
*   **Parameters**:
    *   `mode` (InterruptMode): The desired interrupt mode.
*   **Returns**: A `Result` indicating success or a `DriverError` on failure.

#### `destroy(self) -> I2C`

*   **Description**: Safely cleans up the device and returns any owned peripherals.
*   **Returns**: The owned I2C peripheral.
```

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

### Initialize and Configure FT6x06 Touch Screen Driver (Rust)

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/index

Demonstrates the initialization and configuration of the synchronous FT6x06 driver. It shows how to set interrupt modes, control modes, report rates, and read back these settings. Requires an I2C peripheral.

```Rust
// Initialization
let mut dev = FT6x06::new(i2c);

// Configure the device.
dev.set_interrupt_mode(InterruptMode::Trigger)?;
dev.set_control_mode(ControlMode::MonitorIdle)?;
dev.set_active_idle_timeout(10)?;
dev.set_report_rates(60, 25)?;

// Read the device configuration.
let interrupt_mode = dev.get_interrupt_mode()?;
let control_mode = dev.get_control_mode()?;
let active_idle_timeout = dev.get_active_idle_timeout()?;
let (active_rate, monitor_rate) = dev.get_report_rates()?;

info!("Irq Mode: {}", interrupt_mode);
info!("Ctrl Mode: {}", control_mode);
info!("Active Idle Timeout: {}", active_idle_timeout);
info!("Active Rate: {}", active_rate);
info!("Monitor Rate: {}", monitor_rate);

// Get the latest touch data. Usually after receiving an interrupt from the device.
let touch_event = dev.get_touch_event()?;
```

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

### Get Interrupt Mode

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=u32+-%3E+bool

Retrieves the current interrupt mode configuration of the device.

```APIDOC
## Get Interrupt Mode

### Description
Gets the current interrupt mode. This corresponds to the `G_MODE` register.

### Method
`get_interrupt_mode`

### Endpoint
N/A (Method call)

### Parameters
None

### Request Example
```rust
match ft6x06.get_interrupt_mode().await {
    Ok(mode) => {
        println!("Interrupt mode: {:?}", mode);
    }
    Err(e) => {
        // Handle error
    }
}
```

### Response
#### Success Response (200)
- **Result<InterruptMode, DriverError<I2C::Error>>** - A `Result` containing the current `InterruptMode` or a `DriverError`.

#### Response Example
```json
"InterruptMode::Touch"
```
```

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

### Interrupt Mode API

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/sync.rs_search=u32+-%3E+bool

APIs for getting and setting the interrupt mode of the device.

```APIDOC
## Get Interrupt Mode

### Description
Gets the current interrupt mode of the FT6x06 device.

### Method
`get_interrupt_mode`

### Endpoint
Reads from the `G_MODE` register (0x07).

### Parameters
None

### Request Example
```rust
let interrupt_mode = ft6x06.get_interrupt_mode()?;
```

### Response
#### Success Response (200)
- **InterruptMode** - The current interrupt mode.

## Set Interrupt Mode

### Description
Sets the interrupt mode of the FT6x06 device.

### Method
`set_interrupt_mode`

### Endpoint
Writes to the `G_MODE` register (0x07).

### Parameters
- **mode** (InterruptMode) - The desired interrupt mode to set.

### Request Example
```rust
ft6x06.set_interrupt_mode(InterruptMode::Touch)?;
```

### Response
#### Success Response (200)
- **()** - Indicates successful operation.
```

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

### FT6x06 Device Initialization and Core Functions

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06_search=std%3A%3Avec

This section covers the initialization of the FT6x06 device and core functionalities like retrieving touch events and managing device control modes.

```APIDOC
## FT6x06<I2C>

### Description
An FT6x06 device. This struct contains the full sync interface to the FT6x06 device. Certain features depend upon the specific FT6x06 chip and firmware version and some data or functionality may be unavailable.

### Methods

#### `new(i2c: I2C) -> Self`

Initializes a new FT6x06 device instance.

#### `get_touch_event(&mut self) -> Result<Option<TouchEvent>, DriverError<I2C::Error>>`

Retrieves the latest touch event with all available data and touch points.

#### `get_control_mode(&mut self) -> Result<ControlMode, DriverError<I2C::Error>>`

Gets the current mode of the device. This corresponds to the `CTRL` register.

#### `set_control_mode(&mut self, mode: ControlMode) -> Result<(), DriverError<I2C::Error>>`

Sets the device mode. The default control mode is `ControlMode::MonitorIdle`. This corresponds to the `CTRL` register.

### Request Example
```rust
// Example for initializing and getting control mode
let i2c_bus = /* ... your I2C bus implementation ... */;
let mut ft6x06_device = FT6x06::new(i2c_bus);
let current_mode = ft6x06_device.get_control_mode()?;
println!("Current control mode: {:?}", current_mode);
```

### Response Example
```json
{
  "success": true,
  "data": {
    "control_mode": "MonitorIdle"
  }
}
```
```

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

### FT6x06Async Device Initialization

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=u32+-%3E+bool

Initializes a new FT6x06Async device with the provided I2C peripheral.

```APIDOC
## FT6x06Async Device Initialization

### Description
Initializes a new FT6x06Async device with the provided I2C peripheral.

### Method
`new`

### Parameters
- **i2c** (I2C) - The I2C peripheral to use for communication.

### Request Example
```rust
let mut ft6x06 = FT6x06Async::new(i2c_peripheral);
```

### Response
- **FT6x06Async<I2C>** - An instance of the FT6x06Async device.
```

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

### FT6x06 Device Initialization

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06

Initializes a new FT6x06 device instance using an I2C peripheral.

```APIDOC
## POST /ft6x06/new

### Description
Initializes a new FT6x06 device instance.

### Method
POST

### Endpoint
/ft6x06/new

### Parameters
#### Query Parameters
- **i2c** (I2C) - Required - The I2C peripheral to use for communication.

### Request Example
```json
{
  "i2c": "<I2C_PERIPHERAL_INSTANCE>"
}
```

### Response
#### Success Response (200)
- **FT6x06** (object) - The initialized FT6x06 device instance.

#### Response Example
```json
{
  "FT6x06": "<INITIALIZED_DEVICE_INSTANCE>"
}
```
```

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

### FT6x06Async Device Interaction

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs

Provides methods for initializing and interacting with the FT6x06 touch controller asynchronously.

```APIDOC
## FT6x06Async<I2C>

### Description
Represents an FT6x06 device with an asynchronous interface. Functionality may vary based on the specific FT6x06 chip and firmware version.

### Methods

#### `new(i2c: I2C) -> Self`

Creates a new instance of `FT6x06Async`.

- **i2c** (I2C) - The I2C bus interface.

#### `wait_for_touch<P: Wait>(&mut self, irq: &mut P) -> Result<Option<TouchEvent>, DriverError<I2C::Error>>`

Waits for the next touch event interrupt from the specified IRQ pin.

- **irq** (P: Wait) - A mutable reference to the IRQ pin object implementing the `Wait` trait.

Returns `Ok(Some(TouchEvent))` upon successful detection of a touch event, `Ok(None)` if no event is detected within the timeout (if applicable), or `Err(DriverError)` if an error occurs.

#### `get_touch_event(&mut self) -> Result<Option<TouchEvent>, DriverError<I2C::Error>>`

Retrieves the latest touch event with all available data and touch points.

Reads data from registers 0x01 to 0x0E.

Returns `Ok(Some(TouchEvent))` containing the touch data, `Ok(None)` if no touch data is available, or `Err(DriverError)` if an I2C communication error occurs.

### Request Example
```rust
// Assuming `i2c` is an initialized I2C peripheral and `irq_pin` is configured as an input with interrupt capability
let mut ft6x06 = FT6x06Async::new(i2c);
let touch_event = ft6x06.get_touch_event().await;
match touch_event {
    Ok(Some(event)) => {
        println!("Touch event detected: {:?}", event);
    }
    Ok(None) => {
        println!("No touch event data available.");
    }
    Err(e) => {
        eprintln!("Error getting touch event: {:?}", e);
    }
}
```

### Response Example
```json
{
  "Some(TouchEvent)": {
    "gesture_id": 0,
    "touch_points": [
      {
        "x": 100,
        "y": 200,
        "z": 1
      }
    ]
  }
}
```
```

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

### Get Active Idle Timeout

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=u32+-%3E+bool

Retrieves the idle timeout duration for the `ControlMode::MonitorIdle` mode.

```APIDOC
## Get Active Idle Timeout

### Description
Gets the idle timeout for the [`ControlMode::MonitorIdle`] mode. This corresponds to the `TIMEENTERMONITOR` register.

### Method
`get_active_idle_timeout`

### Endpoint
N/A (Method call)

### Parameters
None

### Request Example
```rust
match ft6x06.get_active_idle_timeout().await {
    Ok(timeout) => {
        println!("Idle timeout: {}", timeout);
    }
    Err(e) => {
        // Handle error
    }
}
```

### Response
#### Success Response (200)
- **Result<u8, DriverError<I2C::Error>>** - A `Result` containing the timeout value as a `u8` or a `DriverError`.

#### Response Example
```json
10
```
```

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

### Initialize FT6x06 Async Driver

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/asynch.rs_search=

Creates a new instance of the FT6x06Async driver. This struct provides the asynchronous interface to the FT6x06 device, requiring an I2C peripheral that implements the `embedded_hal_async::i2c::I2c` trait.

```rust
pub struct FT6x06Async<I2C> {
    i2c: I2C,
}

impl<I2C: I2c<SevenBitAddress>> FT6x06Async<I2C> {
    pub fn new(i2c: I2C) -> Self {
        Self { i2c }
    }
}
```

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

### Initialize FT6x06 Device (Rust)

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/sync.rs_search=u32+-%3E+bool

Creates a new instance of the FT6x06 driver with the provided I2C peripheral. The I2C peripheral must implement the `embedded_hal::i2c::I2c` trait for `SevenBitAddress`.

```rust
pub fn new(i2c: I2C) -> Self {
    Self { i2c }
}
```

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

### FT6x06 Device Initialization

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/sync.rs_search=u32+-%3E+bool

Initializes a new FT6x06 device instance with the provided I2C peripheral.

```APIDOC
## FT6x06 Device Initialization

### Description
Initializes a new FT6x06 device instance with the provided I2C peripheral.

### Method
`new`

### Parameters
- **i2c** (I2C) - The I2C peripheral to use for communication.

### Request Example
```rust
let mut ft6x06 = FT6x06::new(i2c_peripheral);
```

### Response
- **FT6x06<I2C>** - A new instance of the FT6x06 device.
```

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

### Active Idle Timeout API

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/sync.rs_search=u32+-%3E+bool

APIs for getting and setting the idle timeout duration for monitor mode.

```APIDOC
## Get Active Idle Timeout

### Description
Gets the idle timeout duration for the `ControlMode::MonitorIdle` mode.

### Method
`get_active_idle_timeout`

### Endpoint
Reads from the `TIMEENTERMONITOR` register (0x04).

### Parameters
None

### Request Example
```rust
let timeout = ft6x06.get_active_idle_timeout()?;
```

### Response
#### Success Response (200)
- **u8** - The idle timeout value.

## Set Active Idle Timeout

### Description
Sets the idle timeout duration for the `ControlMode::MonitorIdle` mode.

### Method
`set_active_idle_timeout`

### Endpoint
Writes to the `TIMEENTERMONITOR` register (0x04).

### Parameters
- **timeout** (u8) - The desired idle timeout value.

### Request Example
```rust
ft6x06.set_active_idle_timeout(15)?;
```

### Response
#### Success Response (200)
- **()** - Indicates successful operation.
```

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

### Asynchronous FT6x06 Touch Event Handling (Rust)

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/index_search=std%3A%3Avec

Illustrates how to use the asynchronous driver for the FT6x06 touch screen controller, specifically demonstrating the `wait_for_touch` functionality. This requires an I2C peripheral and an interrupt-capable GPIO pin. The code continuously waits for and processes touch events.

```rust
use ft6x06_rs::FT6X06Async;
use embedded_hal::digital::v2::InputPin;
use embedded_hal::digital::v2::PinState;
use embedded_hal::digital::v2::StatefulOutputPin;
use embedded_hal::digital::v2::ToggleableOutputPin;
use embedded_hal::digital::v2::OutputPin;
use embedded_hal::digital::v2::Pull;

// Assuming 'i2c' is a valid embedded-hal-async I2C peripheral
// Assuming 'my_periph.GPIO_XX' is an interrupt-capable GPIO pin
let mut dev_async = FT6X06Async::new(i2c);
let mut irq_pin = Input::new(my_periph.GPIO_XX, Pull::Up);

// In the async driver, you can wait for the next touch event:
loop {
    let touch_event = dev_async.wait_for_touch(&mut irq_pin).await?;
    // Assuming 'info!' macro is available for logging
    // info!("{:?}", touch_event);
}
```

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

### Initialize FT6x06 Device

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06

Creates a new instance of the FT6x06 device. This function requires an I2C peripheral that supports 7-bit addressing. It returns the initialized FT6x06 struct.

```rust
pub fn new(i2c: I2C) -> Self
```

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

### Asynchronously Wait for Touch Event with FT6x06 (Rust)

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs_search=

Illustrates how to asynchronously wait for a touch event using the `ft6x06-rs` crate. This requires the `async-driver` feature and an asynchronous I2C peripheral. It demonstrates waiting for an interrupt on a GPIO pin and then retrieving the touch event data.

```Rust
use ft6x06_rs::FT6X06Async;
use embedded_hal_async::i2c::I2C;
use embedded_hal::digital::v2::InputPin;
use embedded_hal::digital::v2::PinState;
use embedded_hal::digital::v2::StatefulPin;
use embedded_hal::digital::v2::ToggleableOutputPin;
use embedded_hal::digital::v2::OutputPin;
use embedded_hal::digital::v2::Pull;

// Assuming 'i2c' is a valid async I2C peripheral implementing embedded_hal_async::i2c::I2C
// Assuming 'my_periph.GPIO_XX' is a GPIO pin configured as input with pull-up
// let mut dev_async = FT6X06Async::new(i2c);
// let mut irq_pin = Input::new(my_periph.GPIO_XX, Pull::Up);

// loop {
//     let touch_event = dev_async.wait_for_touch(&mut irq_pin).await?;
//     info!("{:?}", touch_event);
// }
```

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

### Get Touch Event

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/sync.rs_search=u32+-%3E+bool

Retrieves the latest touch event data, including gesture information and touch point coordinates.

```APIDOC
## Get Touch Event

### Description
Retrieves the latest touch event with all available data and touch points.

### Method
`get_touch_event`

### Endpoint
Reads from registers 0x01 to 0x0E.

### Parameters
None

### Request Example
```rust
let touch_event = ft6x06.get_touch_event()?;
```

### Response
#### Success Response (200)
- **Option<TouchEvent>** - An optional `TouchEvent` struct containing gesture ID, touch status, and touch point data.

#### Response Example
```json
{
  "gesture_id": 0,
  "num_touches": 1,
  "touches": [
    {
      "x": 100,
      "y": 200,
      "id": 0
    }
  ]
}
```
```

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

### Get Interrupt Mode (Rust)

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06Async_search=u32+-%3E+bool

Asynchronously reads the current interrupt mode of the device from the G_MODE register. This determines how the device signals events.

```rust
pub async fn get_interrupt_mode( &mut self, ) -> Result<InterruptMode, DriverError<I2C::Error>>
```

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

### Initialize FT6x06 Driver (Rust)

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/sync.rs_search=std%3A%3Avec

Creates a new instance of the FT6x06 driver. It requires an I2C peripheral that implements the `embedded_hal::i2c::I2c` trait for SevenBitAddress communication.

```rust
pub fn new(i2c: I2C) -> Self {
        Self { i2c }
    }
```

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

### Get Interrupt Mode (Rust)

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06_search=u32+-%3E+bool

Retrieves the current interrupt mode of the device, corresponding to the `G_MODE` register. Returns a `Result` containing the `InterruptMode` or a `DriverError`.

```rust
pub fn get_interrupt_mode( &mut self, ) -> Result<InterruptMode, DriverError<I2C::Error>>
```

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

### FT6x06Async Device Interface

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06Async

This section covers the core asynchronous methods for interacting with the FT6x06 device, including retrieving touch events, managing device modes, and configuring report rates.

```APIDOC
## FT6x06Async Device Interface

### `new(i2c: I2C) -> Self`

Creates a new `FT6x06Async` instance.

### `wait_for_touch<P: Wait>(&mut self, irq: &mut P) -> Result<Option<TouchEvent>, DriverError<I2C::Error>>`

Waits for the next touch event interrupt from the specified IRQ pin.

### `get_touch_event(&mut self) -> Result<Option<TouchEvent>, DriverError<I2C::Error>>`

Retrieves the latest touch event with all available data and touch points.

### `get_control_mode(&mut self) -> Result<ControlMode, DriverError<I2C::Error>>`

Gets the current mode of the device (corresponds to the `CTRL` register).

### `set_control_mode(&mut self, mode: ControlMode) -> Result<(), DriverError<I2C::Error>>`

Sets the device mode. The default is `ControlMode::MonitorIdle` (corresponds to the `CTRL` register).

### `get_active_idle_timeout(&mut self) -> Result<u8, DriverError<I2C::Error>>`

Gets the idle timeout for `ControlMode::MonitorIdle` (corresponds to the `TIMEENTERMONITOR` register).

### `set_active_idle_timeout(&mut self, timeout: u8) -> Result<(), DriverError<I2C::Error>>`

Sets the idle timeout for `ControlMode::MonitorIdle`. The default is 10 (corresponds to the `TIMEENTERMONITOR` register).

### `get_report_rates(&mut self) -> Result<(u8, u8), DriverError<I2C::Error>>`

Gets the configured report rates for active and monitor modes (corresponds to `PERIODACTIVE` and `PERIODMONITOR` registers).

### `set_report_rates(&mut self, active_rate: u8, monitor_rate: u8) -> Result<(), DriverError<I2C::Error>>`

Sets the configured report rates for active and monitor modes. The default rates are 60Hz for active and 25Hz for monitor mode (corresponds to `PERIODACTIVE` and `PERIODMONITOR` registers).

### `get_interrupt_mode(&mut self) -> Result<InterruptMode, DriverError<I2C::Error>>`

Gets the current interrupt mode (corresponds to the `G_MODE` register).

### `set_interrupt_mode(&mut self, mode: InterruptMode) -> Result<(), DriverError<I2C::Error>>`

Sets the current interrupt mode (corresponds to the `G_MODE` register).
```

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

### Get FT6x06 Control Mode (Rust)

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06_search=u32+-%3E+bool

Retrieves the current operating mode of the FT6x06 device, corresponding to the `CTRL` register. It returns a `Result` containing the `ControlMode` or a `DriverError`.

```rust
pub fn get_control_mode( &mut self, ) -> Result<ControlMode, DriverError<I2C::Error>>
```

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

### Device Cleanup

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06

Safely cleans up the FT6x06 device and returns any owned peripherals.

```APIDOC
## POST /ft6x06/destroy

### Description
Safely cleans up the FT6x06 device, returning any owned peripherals.

### Method
POST

### Endpoint
/ft6x06/destroy

### Parameters
#### Query Parameters
- **self** (FT6x06) - Required - The FT6x06 device instance to destroy.

### Request Example
```json
{
  "self": "<DEVICE_INSTANCE_TO_DESTROY>"
}
```

### Response
#### Success Response (200)
- **I2C** - The I2C peripheral instance that was owned by the FT6x06 device.

#### Response Example
```json
{
  "I2C": "<RETURNED_I2C_PERIPHERAL>"
}
```
```

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

### Control Mode Operations

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06

Provides methods to get and set the control mode of the FT6x06 device. The control mode corresponds to the `CTRL` register. The default mode is `ControlMode::MonitorIdle`.

```rust
pub fn get_control_mode(&mut self) -> Result<ControlMode, DriverError<I2C::Error>>
```

```rust
pub fn set_control_mode(&mut self, mode: ControlMode) -> Result<(), DriverError<I2C::Error>>
```

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

### Get Report Rates (Rust)

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06Async_search=u32+-%3E+bool

Asynchronously retrieves the configured report rates for both active and monitor modes from the PERIODACTIVE and PERIODMONITOR registers. Returns a tuple of two u8 values.

```rust
pub async fn get_report_rates( &mut self, ) -> Result<(u8, u8), DriverError<I2C::Error>>
```

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

### Destroy Device

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/sync.rs_search=

Safely cleans up the device, returning any owned peripherals.

```APIDOC
## DELETE /device

### Description
Safely cleans up the device and returns any owned peripherals.

### Method
DELETE

### Endpoint
/device

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **peripheral** (object) - The returned peripheral object.

#### Response Example
```json
{
  "peripheral": {
    "type": "I2C"
  }
}
```
```

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

### Get Latest Touch Event (Rust)

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06Async_search=u32+-%3E+bool

Asynchronously retrieves the most recent touch event data, including all available information and touch points. Returns an Option<TouchEvent> or a DriverError.

```rust
pub async fn get_touch_event( &mut self, ) -> Result<Option<TouchEvent>, DriverError<I2C::Error>>
```

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

### Rust: Implement TryInto for Conversions

Source: https://docs.rs/ft6x06-rs/latest/ft6x06_rs/struct.FT6x06Async_search=std%3A%3Avec

Implements the `try_into` method, which performs a conversion from type `T` to type `U`. It returns a `Result` that is either the converted value of type `U` or an error of the associated `Error` type.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

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

### Asynchronous Touch Event Handling with FT6x06 (Rust)

Source: https://docs.rs/ft6x06-rs/latest/src/ft6x06_rs/lib.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to use the asynchronous driver (`FT6x06Async`) to wait for touch events. This is useful in embedded systems where non-blocking operations are preferred. It requires an interrupt pin configured as an input.

```rust
let mut irq_pin = Input::new(my_periph.GPIO_XX, Pull::Up);
let mut dev_async = FT6x06Async::new(i2c);

loop {
    let touch_event = dev_async.wait_for_touch(&mut irq_pin).await?;
    info!("{:?}", touch_event);
}
```
Tokens:
Raw