The GT911 register map is not beautiful. It’s not a work of art like an I2C accelerometer with neat, aligned 16-bit registers. It is a tool. It is brutally efficient.
Final advice to future engineers: Copy the factory default config first. Never trust your own checksum calculation on the first try. Use a logic analyzer. And for the love of all that is holy, treat the Refresh Flag (0x80FF) with the respect it deserves—it is the "Are you sure?" button of the embedded world.
Bottom Line: 4 stars. One star deducted because the documentation for the config registers is scattered across three different versions of the datasheet. But the register map itself? Once you understand its quirks, it’s a reliable old friend. Just don’t forget to clear the buffer flag.
Would I recommend it? Yes, if you like your peripherals cheap, responsive, and full of character. No, if you want a register map that holds your hand.
The Go to product viewer dialog for this item. is a popular capacitive touch screen controller used in many small displays. Its register map is organized into four main functional blocks that you access via I2C. GT911 Register Map Summary
The device uses 16-bit register addresses (high byte first). Register Range Key Details 0x8040 – 0x8046 Command & Status
Used to send commands (e.g., reset, sleep) and check current chip status. 0x8047 – 0x80FF Configuration
Stores settings like screen resolution, touch sensitivity, and interrupt triggers. 0x8100 – 0x813F Coordinate Data
Contains the X/Y coordinates and pressure for up to 5 simultaneous touch points. 0x8140 – 0x814E Product Information Includes the Product ID, firmware version, and hardware ID. Commonly Used Registers 0x8140 – 0x8143: Product ID (usually "911" in ASCII).
0x814E: Buffer Status. When a touch is detected, the highest bit (bit 7) is set to 1. You must write a 0 back to this register after reading coordinates to clear the status.
0x8150: Start of the first touch point data (Point 1 X-coordinate low byte).
For detailed implementation steps, you can refer to technical guides like the Focus LCDs GT911 Programming Note.
is a popular 5-point capacitive touch controller that communicates via
. Understanding its register map is essential for configuring the screen, handling touch events, and reading coordinates. Key Hardware Details I2C Addresses: The chip supports two addresses, (default) or , depending on the state of the pin during power-on. Essential Pins: VDD, GND, SCL, SDA, (touch event interrupt), and Crystalfontz Core Register Map Highlights The register addresses are
allows for continuous reading; it will automatically increment the address after each byte is sent STMicroelectronics Community GOODiX GT911 Programming Guide 2014-08-04_Rev.00
The Goodix GT911 5-point capacitive touch controller utilizes 16-bit register addresses via I2C, with memory divided into command, configuration, and coordinate data sections. Key registers include 0x8040 for power management and 0x8140 for touch data, requiring careful handling of coordinate status flags to ensure accurate input detection. For technical documentation, refer to the STMicroelectronics Community document and the Focus LCDs article on programming a capacitive touch panel.
Understanding the GT911 Register Map: A Guide for Developers
is a popular 5-point capacitive touch controller used extensively in small-to-medium-sized mobile devices and embedded systems. For developers building custom drivers, understanding its register map
is critical for initializing the device, configuring touch parameters, and reading real-time coordinate data.
This post breaks down the register structure and communication protocols needed to master the Go to product viewer dialog for this item. 1. Register Address Overview 16-bit register addressing scheme
. Its memory space is logically divided into four primary functional blocks: Register Range Description Access Type 0x8040 – 0x8046 Command and Status Read/Write (R/W) 0x8047 – 0x80FF Device Configuration Read/Write (R/W) 0x8100 – 0x813F Coordinate Data (Touch Points) Read-Only (R) 0x8140 – 0x814E Product ID and Hardware Info Read-Only (R) 2. Core Functional Blocks Command & Status (0x8040 – 0x8046)
This block controls the high-level operational state of the chip. 0x8040 (Command Register):
Used to issue real-time commands such as entering sleep mode, screen off, or triggering a reference capacitance update. 0x8046 (Command Check): gt911 register map
For commands greater than 0x07, this register must be written before 0x8040 to improve ESD (Electrostatic Discharge) protection. Configuration Registers (0x8047 – 0x80FF)
This massive block defines how the touch panel behaves. It includes settings for: Resolution: Horizontal and vertical pixel counts (e.g., 480x800). Touch Points: Setting the maximum number of concurrent touches (up to 5). Sensitivity: Touch thresholds and noise rejection levels. Refresh Rate: Typically set to 5ms or 10ms cycles. Saving Changes: After writing to these registers, you must write 0x01 to 0x8040 to save the config to non-volatile memory, followed by to transition into application mode. Coordinate Data (0x8100 – 0x813F) When a touch is detected, the updates this range with live data
This specific address often contains the "Buffer Status," which indicates the number of active touch points. Touch Information:
Each touch point includes X/Y coordinates and touch pressure/size attributes. 3. I2C Communication Protocol
The GT911 communicates as an I2C slave. Depending on the state of the INT and RESET pins during power-up, the device address can be either
Send the 16-bit register address (high byte then low byte) followed by the data bytes.
First, perform a dummy write of the 16-bit address you want to read from. Then, issue a restart condition and read the data. Auto-Increment:
The GT911 automatically increments the register address after every read or write, allowing you to pull all coordinate data in a single burst. 4. Best Practices for Implementation Wait for INT: Instead of constant polling, use the to trigger a read only when new touch data is ready. Verify Product ID: Always read the registers at
during startup to verify you are talking to the correct hardware before applying configurations. ESD Protection: Regularly write and check the value at register if your device operates in high-interference environments. 3. Register Map
The GT911 register map is the architectural blueprint used to interface with the Goodix GT911 capacitive touch controller. It defines how a host processor (like an STM32, Arduino, or Raspberry Pi) communicates via I2C to configure the touch panel, read coordinates, and manage power modes.
Understanding this map is essential for developers writing custom drivers or troubleshooting touch response issues in embedded systems. 1. Communication Basics
The GT911 operates as an I2C slave. Before accessing the register map, you must establish the correct slave address.
Slave Addresses: Depending on the state of the INT and RESET pins during power-on, the device uses either 0xBA/0xBB or 0x28/0x29 (8-bit write/read format).
Address Pointer: The GT911 uses 16-bit register addresses. It supports auto-incrementing, allowing you to read or write a continuous block of data in a single I2C transaction. 2. Core Register Map Structure
The register map is divided into three primary functional areas: Address Range Access Type Description 0x8040 Command Register Write Only Sends high-level commands like Sleep or Calibration. 0x8047 – 0x8100 Configuration Registers Read/Write
Defines screen resolution, touch thresholds, and sensor layout. 0x8140 – 0x8177 Coordinate/Status Registers
Contains the touch point status and X/Y coordinates for up to 5 points. 3. Key Functional Registers Command Register (0x8040)
This register is used to trigger specific device states. Common commands include: 0x00: Read coordinate status. 0x05: Enter Screen-off mode to save power. 0x06/0x07: Enter/Exit Charge mode for enhanced sensitivity. Configuration Registers (0x8047+)
This block is often sent as a complete "config array" during initialization. 3. Register Map
Understanding the GT911 Register Map: A Comprehensive Guide
The GT911 is a popular capacitive touch screen controller chip used in various electronic devices, including smartphones, tablets, and laptops. To effectively communicate with the GT911 chip, it's essential to understand its register map. In this blog post, we'll dive into the details of the GT911 register map, exploring its structure, functions, and applications.
Introduction to GT911
The GT911 is a highly integrated touch screen controller chip developed by GTCOM (Guangdong GTCOM Technology Co., Ltd.). It's designed to detect touch events on capacitive touch screens, providing a robust and reliable user interface. The GT911 supports various interfaces, including I2C, SPI, and USB, making it a versatile solution for a wide range of applications.
GT911 Register Map Overview
The GT911 register map is a set of memory-mapped registers that store configuration data, control the chip's behavior, and report touch events. The register map is divided into several sections, each serving a specific purpose:
GT911 Register Map Structure
The GT911 register map consists of 256 registers, each 8 bits wide. The registers are organized into several sections, with each section having a specific function. Here's a breakdown of the GT911 register map:
| Register Address | Section | Description | | --- | --- | --- | | 0x00-0x0F | Configuration | Touch sensitivity, debounce time, and gesture recognition settings | | 0x10-0x1F | Control | Power management, interrupt handling, and communication interface settings | | 0x20-0x3F | Status | Touch event detection, gesture recognition, and error flags | | 0x40-0x5F | Data | Touch coordinates, pressure, and gesture information | | 0x60-0xFF | Reserved | Reserved for future use or proprietary functions |
Key Registers and Functions
Here are some key registers and their functions:
Applications and Use Cases
Understanding the GT911 register map is essential for developing applications that utilize the chip's features. Here are some use cases:
Conclusion
In conclusion, the GT911 register map is a critical component of the GT911 touch screen controller chip. Understanding its structure, functions, and applications is essential for developing efficient and reliable touch screen interfaces. This blog post provides a comprehensive guide to the GT911 register map, covering its overview, structure, key registers, and use cases. Whether you're a developer, engineer, or simply interested in touch screen technology, this guide should provide valuable insights into the GT911 register map.
The Goodix GT911 Go to product viewer dialog for this item. is a popular 5-point capacitive touch controller used in various small-to-medium-sized displays for automotive, mobile, and DIY electronics. Interfacing with this chip requires communicating via I2C and interacting with its structured internal memory known as the Register Map. Core Communication Basics
uses a standard I2C interface with a 16-bit register address.
Slave Address: Commonly 0x5D or 0x14, depending on how the INT pin is pulled during reset.
Register Addressing: Always send two bytes for the register address (High byte then Low byte) before reading or writing data.
Auto-Increment: The chip automatically increments the register address, allowing you to read multiple touch points in a single session. Register Map Summary
The register map is divided into functional blocks. Below are the primary addresses you will need for basic driver development.
| Address Range | Function Block | Key Registers & Details |
| :--- | :--- | :--- || 0x8040 | Command | Writing 0x00 (read coordinates), 0x01 (read raw data), or 0x05 (screen off). || 0x8047 – 0x813F | Configuration | Settings for resolution, touch thresholds, and sensor orientation. || 0x8140 – 0x8143 | Product ID | Reads as ASCII "911" or "9111" to verify chip identity. || 0x814E | Status | Critical: Bit 7 (Buffer Status) indicates new touch data is ready. Writing 0 here clears the flag. || 0x814F – 0x8156 | Touch 1 Data | Contains Track ID, X-coordinate (Low/High), Y-coordinate, and Size. || 0x8157 – 0x81FF | Touch 2–5 Data | Subsequent blocks (8 bytes each) for the remaining touch points. | The Reading Workflow
To retrieve touch coordinates reliably, you should follow this sequence according to the GT911 Programming Guide:
Wait for Interrupt: Monitor the INT pin or poll the Status Register (0x814E) until Bit 7 becomes 1. The GT911 register map is not beautiful
Read Point Count: The lower 4 bits of register 0x814E tell you how many fingers (0–5) are currently on the screen.
Fetch Coordinates: Read the coordinate registers for each active point. For example, Point 1's X-coordinate is at 0x8150 (Low) and 0x8151 (High).
Clear Status: Write 0x00 back to register 0x814E. If you skip this, the chip will not update the buffer with new data. Implementation Resources
If you are developing for specific platforms, these verified libraries and guides can save hours of debugging: 3. Register Map
The story of the GT911 Register Map is not a story of a single document, but a tale of reverse engineering, evolving firmware, and the democratization of touch technology.
It begins around the early 2010s. Capacitive touchscreens were transitioning from luxury items (like the original iPhone) to standard components in consumer electronics. Goodix, a Chinese semiconductor company, released the GT911—a capacitive touch controller that was powerful, responsive, and significantly cheaper than competitors like FocalTech or Cypress.
However, Goodix operated under a strict "NDA-only" policy for their datasheets. The official register map was a guarded secret, available only to large manufacturers. This is the story of how that map was drawn.
Just when the community thought they had the map memorized, Goodix released an update. The chip was now labeled GT9110 (sometimes called the "Red" series firmware).
The register map changed. The configuration offset 0x6A (which previously set the number of touch points) moved. The checksum calculation method changed. Suddenly, old drivers broke.
This forced the open-source community (particularly contributors to the Linux Kernel and projects like ESP32 Arduino core) to write "auto-detect" routines. The code had to probe the registers, trying to read the "Goodix" ID (GT911, GT9110, etc.) stored in the read-only memory area (around 0x8140 to 0x8143) to decide which map to use.
| Register | Description | |----------|-------------| | 0x80FE | Config checksum (calculated by host) | | 0x80FF | Config update flag (write 0x01 to reload config from host) |
After writing a new configuration block to 0x8040–0x80FD, you must:
The GT911 will then reset its touch engine with the new settings.
Typical startup config area (example offsets):
| Offset | Field | Typical value |
|--------|-------|----------------|
| 0x8048-0x804D | X/Y resolution | Depends on display |
| 0x8060 | Touch threshold | 0x46 (70 raw) |
| 0x8061 | Filter coefficient | 0x05 |
| 0x807C | I2C watchdog | 0x09 (9 sec) |
Important: After writing config, write
0x00to0x80FE(soft reset) and send0x01to0x8040(config update flag).
Each touch point occupies 7 bytes:
| Offset | Register | Description |
| :--- | :--- | :--- |
| +0 | 0x8010 | Track ID – A rotating ID (0-31). Same ID across frames = same finger. |
| +1 | 0x8011 | X Coordinate (Low Byte) – Bits 7-0 of X position |
| +2 | 0x8012 | X Coordinate (High Byte) – Bits 11-8 of X position (not 15-12!). Only 12-bit resolution. |
| +3 | 0x8013 | Y Coordinate (Low Byte) – Bits 7-0 of Y position |
| +4 | 0x8014 | Y Coordinate (High Byte) – Bits 11-8 of Y position |
| +5 | 0x8015 | Touch Size (Low Byte) – Area of contact (roughness) |
| +6 | 0x8016 | Touch Size (High Byte) – Typically not used for basic apps |
Formula for coordinates:
X = (read_u16(0x8012) << 8) | read_u8(0x8011) ... Wait, careful. Because the GT911 is big-endian:
int X = ( (regs[0x8012] & 0x0F) << 8 ) | regs[0x8011];
int Y = ( (regs[0x8014] & 0x0F) << 8 ) | regs[0x8013];
Only the lower 12 bits are valid. The upper 4 bits of the high byte are reserved or used for flags.
Your X and Y are swapped or mirrored. The GT911 reports physical panel coordinates, not LCD coordinates. If you rotated your LCD via software, you must either:
Below is the definitive register map for the GT911. All addresses are 16-bit. Note: The GT911 uses Big-Endian (MSB first) for multi-byte values. Final advice to future engineers: Copy the factory
| Start Addr | End Addr | Size (bytes) | Name / Section | Type | Description |
| :--- | :--- | :--- | :--- | :--- | :--- |
| 0x8000 | 0x8000 | 1 | Product ID (MSB) | RO | First char of ID (e.g., '9') |
| 0x8001 | 0x8001 | 1 | Product ID | RO | Second char (e.g., '1') |
| 0x8002 | 0x8002 | 1 | Product ID | RO | Third char (e.g., '1') |
| 0x8003 | 0x8003 | 1 | Product ID (LSB) | RO | Fourth char (e.g., 0x00 for string end) |
| 0x8004 | 0x8004 | 1 | Firmware Version | RO | Major/minor version |
| 0x8005 | 0x8005 | 1 | X Output Maximum (MSB) | RO | Reserved / default |
| 0x8006 | 0x8006 | 1 | X Output Maximum (LSB) | RO | Reserved / default |
| 0x8007 | 0x8007 | 1 | Y Output Maximum (MSB) | RO | Reserved / default |
| 0x8008 | 0x8008 | 1 | Y Output Maximum (LSB) | RO | Reserved / default |
| 0x8009 | 0x800F | 7 | Reserved / Status | RO | Touch count & flags |
| 0x8010 | 0x8024 | 21 | Point 1 Data (TrackID, X, Y, Size) | RO | First touch report |
| 0x8025 | 0x8039 | 21 | Point 2 Data | RO | Second touch report |
| 0x803A | 0x804E | 21 | Point 3 Data | RO | Third touch report |
| 0x804F | 0x8063 | 21 | Point 4 Data | RO | Fourth touch report |
| 0x8064 | 0x8078 | 21 | Point 5 Data | RO | Fifth touch report |
| 0x8079 | 0x807E | 6 | Reserved / Checksum | RO | Touch protocol integrity |
| 0x8040 | 0x8040 | 1 | Gesture ID | RO | Up/Down/Left/Right/Double-Click |
| 0x8041 | 0x80FF | 191 | Reserved | - | Not documented |
| 0x8100 | 0x8100 | 1 | Config Version | RW | Configuration version number |
| 0x8101 | 0x8101 | 1 | X Resolution (MSB) | RW | Screen width (max touch X) |
| 0x8102 | 0x8102 | 1 | X Resolution (LSB) | RW | Screen width |
| 0x8103 | 0x8103 | 1 | Y Resolution (MSB) | RW | Screen height (max touch Y) |
| 0x8104 | 0x8104 | 1 | Y Resolution (LSB) | RW | Screen height |
| 0x8105 | 0x8105 | 1 | Touch Threshold | RW | Finger detection sensitivity (default 80) |
| 0x8106 | 0x8106 | 1 | Active (Screen-On) Gain | RW | Amplification factor for touch |
| 0x8107 | 0x8107 | 1 | Standby (Screen-Off) Gain | RW | Low-power detection gain |
| 0x8108 | 0x8108 | 1 | Debounce | RW | Number of consecutive samples (1-10) |
| 0x8109 | 0x8109 | 1 | Noise Reduction | RW | Filter level (0-7) |
| 0x810A | 0x810A | 1 | Screen Touch Level | RW | Reserved |
| 0x810B | 0x810B | 1 | Proximity Enable | RW | Enable/Disable proximity sensing |
| 0x810C | 0x810C | 1 | Handheld/Pen Enable | RW | Mode selection for stylus |
| 0x810D | 0x811D | 17 | Key Area Array | RW | Physical button mapping |
| 0x811E | 0x812F | 18 | Proximity & Noise Settings | RW | Advanced tuning |
| 0x8130 | 0x813F | 16 | Gesture Parameters | RW | Swipe angles, double-tap timing |