TT21100 Touch Controller

The TT21100 is a touch controller that supports up to 10 touch points. It supports both mutual and self capacitance sensing. It can be used with TT21100 touchpad sensor. This touch controller can be found in the ESP32-S3-BOX.

TT21100 Example
- How to use example
  - Hardware Required
  - Build and Flash
- Example Output

API Reference

Header File

components/tt21100/include/tt21100.hpp

Classes

class Tt21100 : public espp::BasePeripheral<>

Driver for the Tt21100 touch controller.

Example

    // make the I2C that we'll use to communicate
    espp::I2c i2c({
        .port = I2C_NUM_0,
        .sda_io_num = (gpio_num_t)CONFIG_EXAMPLE_I2C_SDA_GPIO,
        .scl_io_num = (gpio_num_t)CONFIG_EXAMPLE_I2C_SCL_GPIO,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
    });
    // now make the tt21100
    auto tt21100 = espp::Tt21100({
        .read = std::bind(&espp::I2c::read, &i2c, std::placeholders::_1, std::placeholders::_2,
                          std::placeholders::_3),
    });

    // and finally, make the task to periodically poll the tt21100 and print
    // the state
    auto task_fn = [&tt21100](std::mutex &m, std::condition_variable &cv) {
      std::error_code ec;
      bool new_data = tt21100.update(ec);
      if (ec) {
        fmt::print("TT21100 update failed: {}\n", ec.message());
        return true; // stop the task
      }
      if (!new_data) {
        // no new data, so don't bother printing
        return false; // don't stop the task
      }
      // get the state
      uint8_t num_touch_points = 0;
      uint16_t x = 0, y = 0;
      tt21100.get_touch_point(&num_touch_points, &x, &y);
      bool button_state = tt21100.get_home_button_state();
      if (num_touch_points == 0 && !button_state) {
        // no touch points, so don't bother printing
      } else if (num_touch_points == 0 && button_state) {
        fmt::print("home button pressed\n");
      } else {
        fmt::print("num_touch_points: {}, x: {}, y: {}, button state: {}\n", num_touch_points, x, y,
                   button_state);
      }
      // NOTE: sleeping in this way allows the sleep to exit early when the
      // task is being stopped / destroyed
      {
        std::unique_lock<std::mutex> lk(m);
        cv.wait_for(lk, 50ms);
      }
      return false; // don't stop the task
    };
    auto task = espp::Task({.callback = task_fn,
                            .task_config = {.name = "TT21100 Task"},
                            .log_level = espp::Logger::Verbosity::WARN});
    task.start();

Public Types

typedef std::function<bool(uint8_t)> probe_fn

Function to probe the peripheral

Param address: The address to probe
Return: True if the peripheral is found at the given address

Public Functions

inline explicit Tt21100(const Config &config)

Constructor.

Parameters: config – The configuration for the driver

inline bool update(std::error_code &ec)

Read the touch data.

Parameters: ec – The error code to set if an error occurs
Returns: True if there is new touch data

inline uint8_t get_num_touch_points() const

Get the number of touch points.

Note

This is the number of touch points that were present when the last update() was called

Returns: The number of touch points

inline void get_touch_point(uint8_t *num_touch_points, uint16_t *x, uint16_t *y) const

Get the touch point data.

Note

This is the touch point data that was present when the last update() was called

Parameters

num_touch_points – The number of touch points
x – The x position of the touch point
y – The y position of the touch point

inline uint8_t get_home_button_state() const

Get the state of the home button.

Note

This is the state of the home button when the last update() was called

Returns: True if the home button is pressed

inline bool probe (std::error_code &ec) requires(UseAddress)

Probe the peripheral

Note

This function is thread safe

Note

If the probe function is not set, this function will return false and set the error code to operation_not_supported

Note

This function is only available if UseAddress is true

Parameters: ec – The error code to set if there is an error
Returns: True if the peripheral is found

inline void set_address (uint8_t address) requires(UseAddress)

Set the address of the peripheral

Note

This function is thread safe

Note

This function is only available if UseAddress is true

Parameters: address – The address of the peripheral

inline void set_probe (const probe_fn &probe) requires(UseAddress)

Set the probe function

Note

This function is thread safe

Note

This should rarely be used, as the probe function is usually set in the constructor. If you need to change the probe function, consider using the set_config function instead.

Note

This function is only available if UseAddress is true

Parameters: probe – The probe function

inline void set_write(const write_fn &write)

Set the write function

Note

This function is thread safe

Note

This should rarely be used, as the write function is usually set in the constructor. If you need to change the write function, consider using the set_config function instead.

Parameters: write – The write function

inline void set_read(const read_fn &read)

Set the read function

Note

This function is thread safe

Note

This should rarely be used, as the read function is usually set in the constructor. If you need to change the read function, consider using the set_config function instead.

Parameters: read – The read function

inline void set_read_register(const read_register_fn &read_register)

Set the read register function

Note

This function is thread safe

Note

This should rarely be used, as the read register function is usually set in the constructor. If you need to change the read register function, consider using the set_config function instead.

Parameters: read_register – The read register function

inline void set_write_then_read(const write_then_read_fn &write_then_read)

Set the write then read function

Note

This function is thread safe

Note

This should rarely be used, as the write then read function is usually set in the constructor. If you need to change the write then

Parameters: write_then_read – The write then read function

inline void set_separate_write_then_read_delay(const std::chrono::milliseconds &delay)

Set the delay between the write and read operations in write_then_read

Note

This function is thread safe

Note

This should rarely be used, as the delay is usually set in the constructor. If you need to change the delay, consider using the set_config function instead.

Note

This delay is only used if the write_then_read function is not set to a custom function and the write and read functions are separate functions.

Parameters: delay – The delay between the write and read operations in write_then_read

inline void set_config(const Config &config)

Set the configuration for the peripheral

Note

This function is thread safe

Note

The configuration should normally be set in the constructor, but this function can be used to change the configuration after the peripheral has been created - for instance if the peripheral could be found on different communications buses.

Parameters: config – The configuration for the peripheral

inline void set_config(Config &&config)

Set the configuration for the peripheral

Note

This function is thread safe

Note

The configuration should normally be set in the constructor, but this function can be used to change the configuration after the peripheral has been created - for instance if the peripheral could be found on different communications buses.