Gt911 Register Map -

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 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.

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

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):

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 a 16-bit addressing scheme used to configure and read data from the Goodix GT911 capacitive touch controller. This high-performance IC supports up to 5-point multi-touch and communicates with a host processor via a standard I2C interface with speeds up to 400 kHz. GT911 Register Map Overview gt911 register map

The register map is organized into functional blocks ranging from real-time commands to coordinate data reporting. Register Range Description Access Type 0x8040 – 0x8046 Command and Status Read/Write (R/W) 0x8047 – 0x80FF Configuration Data Read/Write (R/W) 0x8100 – 0x813F Coordinate Data Read-Only (R) 0x8140 – 0x814E Product ID and Information Read-Only (R) Key Register Descriptions 1. Command Register (0x8040)

This register is used to send operational commands to the GT911. Common commands include: 0x00: Read coordinates status. 0x05: Screen off mode.

0x08: Enter Gesture mode (must be preceded by a write to 0x8046).

0xAA: ESD protection mechanism; drivers should write this value and check it regularly to ensure the chip hasn't reset due to electrostatic discharge. 2. Configuration Registers (0x8047 – 0x80FF)

These registers define how the touch sensor behaves. They are typically written once during initialization.

Resolution (0x8048 – 0x804B): Sets the X and Y axis maximum coordinates. For example, a screen can be configured for depending on these values.

Touch Threshold (0x804D): Determines the sensitivity required to register a touch.

Config Checksum (0x80FF): A vital byte used to validate the entire configuration block. If the checksum is incorrect, the GT911 may ignore the new settings. 3. Coordinate Data (0x8100 – 0x813F) This block reports live touch events.

Status Register (0x814E): The first byte indicates how many touch points are currently detected (bits 0-3) and if new data is ready (buffer status bit 7).

Point Data: Each touch point follows with 6 bytes of data, including Track ID and X/Y coordinates. I2C Communication Protocols

The GT911 uses a 16-bit register address, sent as two 8-bit bytes (High byte then Low byte). 3. Register Map

GT911 register map is a critical reference for developers working with this common capacitive touch controller. It defines how to configure the sensor and retrieve touch data via I2C. Orient Display Core Register Structure The GT911 utilizes a 16-bit register address

system. The map is generally divided into three primary functional areas: Orient Display Real-Time Commands (0x8040):

A write-only register used to trigger immediate actions like reading coordinates, entering screen-off mode, or performing calibrations. Configuration Information (0x8047 – 0x8100):

A read/write area used to set touch thresholds, resolution, and sensor behavior. Coordinate/Status Data (0x814E and above):

Used to read the status of touch points and their X/Y coordinates. Orient Display Key Registers for Developers Writes control codes (e.g., to read coordinates, for screen off). Config Version Indicates the version of the current configuration loaded. Touch Threshold

Determines the sensitivity required to trigger a "touch" event.

bit7 indicates if data is ready to be read; lower bits show the number of touch points. Point 1 X-Low

The start of the data buffer for specific touch coordinates. Development Considerations Datasheed and Register map for the GT911

Typical I2C transfer notes

Use repeated-start reads for multi-byte reads.
Many modules require a small delay (~10–50 ms) after reset before I2C responds.
INT pin is often active-low and signals new data; reading clears it on many modules.

The "Wait, what?" Moment: The Swap XY Mystery

Let’s talk about Register 0x804C (Config Register #6). Bit 2 is the "Swap XY" bit. In a sane world, you set it to 1, the axes swap. In the GT911 world? It works, but it also affects the screen resolution registers (0x8048 and 0x804A).

If you hard-code a swap, but forget to swap your width/height registers, the touch point will be a mirror image across the diagonal. It’s a riddle wrapped in an enigma. The register map is logically laid out, but the interdependence of these bytes feels like a puzzle box.

Final Thoughts

The GT911 is a workhorse, but its register map is surprisingly straightforward once you know where to look. You don’t need a full driver library—just 8-10 register addresses and proper I2C handling.

Next time your touch screen acts up, skip the high-level driver and probe 0x8100 through 0x8177. You’ll see exactly what the controller sees.

Have you struggled with GT911 configuration or interrupt handling? Let me know in the comments below.

Enjoyed this deep dive? Subscribe for more embedded display and touch interface breakdowns.

Introduction

The GT911 is a popular capacitive touch controller chip developed by Goodix, a leading provider of mixed-signal semiconductor solutions. The chip is widely used in various applications, including smartphones, tablets, laptops, and other consumer electronics. To communicate with the GT911 chip, a register map is used to configure and control its functions. In this story, we'll dive into the world of GT911 register maps and explore the intricacies of this complex technical topic.

The Early Days

It was a typical Monday morning at Goodix's headquarters in Shanghai, China. The company's engineering team was busy preparing for the upcoming product launch of their new flagship smartphone. Among them was Alex, a senior engineer responsible for the development of the touch controller module. Alex had been working with the GT911 chip for months and was well-versed in its register map.

For those unfamiliar with the GT911, the register map is a crucial component that defines the chip's configuration and behavior. It's essentially a table that maps addresses to specific functions, allowing the host processor to communicate with the chip. The GT911 register map is divided into several sections, including the configuration registers, data registers, and status registers.

As Alex sipped his coffee, he began to review the GT911 register map, making sure everything was in order for the new product launch. He checked the configuration registers, ensuring that the chip was set to the correct mode of operation. He then verified the data registers, which stored the touch data collected by the chip.

The Problem

Just as Alex was about to take a break, his colleague, Rachel, burst into his office. "Alex, we have a problem!" she exclaimed. "The touch screen on our new smartphone prototype is malfunctioning. The device is reporting incorrect touch coordinates, and we're getting lots of false positives." is a popular 5-point capacitive touch controller that

Alex immediately stopped what he was doing and joined Rachel in debugging the issue. They started by reviewing the GT911 register map, searching for any clues that might indicate the cause of the problem. After a few minutes of analysis, Alex noticed that one of the configuration registers was not set correctly.

The register in question was the "Coordinate Transform" register, which was responsible for converting the raw touch data into screen coordinates. Alex suspected that the incorrect setting was causing the chip to produce faulty coordinates. He quickly updated the register map and reconfigured the chip.

The Solution

With the corrected register map, Alex and Rachel retested the touch screen. To their relief, the issue was resolved, and the device began to report accurate touch coordinates. The problem was solved, but Alex knew that this was only the beginning.

As the product launch drew near, Alex was tasked with creating a comprehensive documentation of the GT911 register map. He spent hours writing and rewriting, making sure that every detail was accurate and clear. The document would serve as a reference guide for the company's engineers and help them troubleshoot any issues that might arise in the future.

The documentation included detailed descriptions of each register, along with examples of how to configure them. Alex also included a section on best practices, outlining the recommended procedures for working with the GT911 chip.

The Launch

The day of the product launch finally arrived, and Alex's team was ready. The new smartphone was unveiled to great fanfare, and the response was overwhelmingly positive. The touch screen was smooth and responsive, thanks in large part to Alex's meticulous work on the GT911 register map.

As the product began to ship, Alex received feedback from customers and colleagues alike. The documentation he created was being used extensively, and the GT911 register map was proving to be a valuable resource.

The Future

Months went by, and the GT911 chip became a staple in the industry. Alex's work on the register map had played a significant role in its success. He continued to work on new projects, but he always looked back on his experience with the GT911 with fondness.

The GT911 register map had been a challenging but rewarding project. Alex had learned a great deal about the intricacies of the chip and the importance of accurate documentation. As the technology landscape continued to evolve, Alex was confident that the GT911 would remain a vital component in many devices.

And so, the story of the GT911 register map came full circle. From the early days of development to the product launch and beyond, Alex's work had ensured that the chip performed flawlessly. The GT911 register map had become an essential part of the company's DNA, a testament to the power of technical expertise and attention to detail.

Epilogue

Years later, Alex was attending a conference on touch controller technology. A young engineer approached him, seeking advice on a project they were working on. The engineer mentioned that they were using the GT911 chip and were struggling with the register map.

Alex smiled, remembering his own experiences with the chip. He handed the engineer a copy of his documentation and shared some words of wisdom. "The GT911 register map may seem daunting at first, but with patience and practice, you'll master it. Always double-check your work, and never hesitate to seek help when you need it."

The engineer thanked Alex and left, feeling more confident about their project. Alex watched them go, feeling a sense of pride and satisfaction. The GT911 register map had been a crucial part of his journey, and he was glad to have been able to share his knowledge with others.

The GT911 Register Map: The Digital Nervous System of Touch

At the heart of modern human-machine interaction lies the Goodix GT911, a highly integrated capacitive touch controller. While the physical sensor detects changes in electrical capacitance, the Register Map serves as the vital digital interface, translating raw analog signals into actionable data for a host processor via I2C. Understanding this map is essential for any engineer looking to tune performance, handle gestures, or debug touch sensitivity. 1. The Architecture of Memory

The GT911 register map is organized into functional blocks, typically accessed through a 16-bit address space. This structure isn't just a list of numbers; it is a hierarchy that defines the life cycle of a touch event:

Configuration Registers (0x8047–0x8100): This block defines the "personality" of the touch panel. It contains parameters for screen resolution (X/Y output), touch thresholds (the sensitivity to a finger press), and noise suppression limits. Modifying these registers allows the controller to adapt to different physical glass thicknesses or environmental interference.

Control Registers (0x8040): Often used for soft resets or changing the operating mode (e.g., switching from active sensing to low-power sleep).

Status and Point Information (0x814E–0x8177): This is the most frequently accessed area. The register at 0x814E acts as a traffic controller; its "Buffer Status" bit signals to the CPU when new touch data is ready. Following this, a series of coordinates (X/Y) and track IDs for up to five simultaneous touch points are stored in sequential memory locations. 2. The Protocol of Interaction

The elegance of the GT911 register map lies in its handshake protocol. To prevent data corruption, the controller uses a "Read-Clear" mechanism. When a touch occurs, the GT911 updates the coordinate registers and sets the "Buffer Status" bit in the status register. The host processor reads the data and must then write a 0 back to that status register. This action tells the GT911, "I have received the data; you are free to update it with the next frame." Without this precise dance, the system would suffer from "ghost" touches or laggy responsiveness. 3. Real-World Implications: Tuning and Debugging

Beyond simple coordinates, the register map offers deep insights into the physics of the touch surface. The Touch Score and Area registers provide a window into how much "flesh" is contacting the screen.

For developers, the register map is the primary tool for solving common hardware hurdles:

Palm Rejection: By adjusting the "Large Area Touch" thresholds in the configuration block, one can program the GT911 to ignore a resting palm while still tracking a fingertip.

Power Optimization: By manipulating the "Refresh Rate" and "Sleep" registers, a device can significantly extend battery life when the screen is idle. Conclusion

The GT911 register map is more than a technical datasheet; it is the bridge between the physical touch of a human finger and the logical world of software. By providing a structured, addressable window into the controller's internal logic, it allows for a level of precision and customization that makes the seamless "swipe and tap" experience of modern devices possible. For the developer, mastering this map is the difference between a frustrating interface and a fluid one.

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. Typical I2C transfer notes

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:

Configuration Registers: These registers store configuration data, such as touch sensitivity, debounce time, and gesture recognition settings.
Control Registers: These registers control the chip's behavior, including power management, interrupt handling, and communication interface settings.
Status Registers: These registers report the chip's status, including touch event detection, gesture recognition, and error flags.
Data Registers: These registers store touch data, including touch coordinates, pressure, and gesture information.

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:

0x00: TOUCH_SENSITIVITY: Sets the touch sensitivity level (0-255)
0x10: POWER_CONTROL: Controls power management (sleep, wake-up, and reset)
0x20: TOUCH_STATUS: Reports touch event detection (touch, release, and gesture recognition)
0x40: TOUCH_COORDINATES: Stores touch coordinates (x, y) and pressure data

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:

Touch Screen Calibration: Adjusting the touch sensitivity and debounce time to optimize touch screen performance
Gesture Recognition: Configuring gesture recognition settings to enable specific gestures (e.g., swipe, tap, and pinch)
Power Management: Controlling power consumption to optimize battery life in portable devices

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.

Unlocking the Secrets of the GT911 Register Map: A Comprehensive Guide

The GT911 is a popular capacitive touch controller chip used in a wide range of applications, from smartphones and tablets to industrial control systems and automotive infotainment systems. One of the key aspects of working with the GT911 is understanding its register map, which is essential for configuring and controlling the chip's various functions. In this article, we will provide a detailed overview of the GT911 register map, including its structure, contents, and applications.

Introduction to the GT911

The GT911 is a highly integrated capacitive touch controller chip developed by Goodix, a leading provider of touchscreen solutions. The chip is designed to support up to 10 touch points and features advanced noise reduction and anti-interference capabilities. The GT911 is widely used in various applications, including consumer electronics, industrial control systems, and automotive infotainment systems.

GT911 Register Map Overview

The GT911 register map is a critical component of the chip's architecture, providing a interface for communication between the host processor and the GT911. The register map is a set of registers that store configuration data, control the chip's functions, and provide status information. The GT911 register map is divided into several sections, each with its own specific functions and characteristics.

Structure of the GT911 Register Map

The GT911 register map consists of 256 registers, each 8 bits wide. The registers are divided into several sections, including:

Configuration Registers: These registers store configuration data for the GT911, such as the touch sensitivity, debounce time, and interrupt settings.
Control Registers: These registers control the chip's functions, such as enabling or disabling the touch controller, setting the scan frequency, and configuring the interrupt output.
Status Registers: These registers provide status information about the GT911, such as touch point data, error flags, and interrupt status.
Data Registers: These registers store touch point data, including x and y coordinates, touch pressure, and other relevant information.

Detailed Description of GT911 Registers

Here is a detailed description of some of the key registers in the GT911 register map:

Register 0x00: Chip ID Register: This register stores the GT911 chip ID, which can be used to identify the chip and verify its functionality.
Register 0x01: Configuration Register 1: This register stores configuration data for the touch controller, including the touch sensitivity and debounce time.
Register 0x02: Control Register 1: This register controls the chip's functions, including enabling or disabling the touch controller and setting the scan frequency.
Register 0x10: Touch Point Data Register: This register stores touch point data, including x and y coordinates, touch pressure, and other relevant information.
Register 0x20: Interrupt Status Register: This register provides interrupt status information, including touch point detection, error flags, and other interrupt sources.

Applications of the GT911 Register Map

Understanding the GT911 register map is essential for developing applications that utilize the chip's advanced features. Some common applications of the GT911 register map include:

Touchscreen Calibration: The GT911 register map provides access to calibration data, which can be used to adjust the touch screen's sensitivity and accuracy.
Touch Point Detection: The GT911 register map provides touch point data, which can be used to detect and track multiple touch points on the screen.
Gesture Recognition: The GT911 register map provides data on touch point movement and velocity, which can be used to recognize gestures such as swiping, pinching, and tapping.
Error Detection and Handling: The GT911 register map provides error flags and status information, which can be used to detect and handle errors such as touch point detection errors or communication errors.

Conclusion

In conclusion, the GT911 register map is a critical component of the chip's architecture, providing a interface for communication between the host processor and the GT911. Understanding the GT911 register map is essential for developing applications that utilize the chip's advanced features, such as touchscreen calibration, touch point detection, gesture recognition, and error detection and handling. This article has provided a comprehensive overview of the GT911 register map, including its structure, contents, and applications. By mastering the GT911 register map, developers can unlock the full potential of the chip and create innovative and reliable touch-based applications.

References

Goodix. (2022). GT911 Datasheet. Retrieved from https://www.goodix.com/en/download/GT911_Datasheet_V1.2.pdf
Goodix. (2022). GT911 User Manual. Retrieved from https://www.goodix.com/en/download/GT911_User_Manual_V1.2.pdf

Appendix

Here is a list of GT911 registers, including their addresses and descriptions:

| Register Address | Register Name | Description | | --- | --- | --- | | 0x00 | Chip ID Register | Stores the GT911 chip ID | | 0x01 | Configuration Register 1 | Stores configuration data for the touch controller | | 0x02 | Control Register 1 | Controls the chip's functions, including enabling or disabling the touch controller | | 0x10 | Touch Point Data Register | Stores touch point data, including x and y coordinates, touch pressure, and other relevant information | | 0x20 | Interrupt Status Register | Provides interrupt status information, including touch point detection, error flags, and other interrupt sources |

Note that this is not an exhaustive list of GT911 registers, but rather a selection of key registers discussed in this article. For a complete list of GT911 registers, refer to the GT911 datasheet or user manual.

The GT911 Register Map (Key Sections)

Below is the essential register map broken into functional groups. All addresses are in hex.

Common Pitfalls

❌ Forgetting to read the freshness flag? The GT911 doesn’t have one — just read 0x8050 repeatedly.
❌ Invalid config checksum? Touch may not work. Compute 16-bit sum of bytes 0x8047–0x81FE and match with 0x804E/0x804F.
❌ Wrong I²C address — try both 0x5D and 0x14 (7-bit).

Part 2: The Global Register Map Table

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.

| 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 |

The 0x00 Register Read Bug

If you read register 0x8000 and always get 0x00, your I²C is working, but the GT911 is not initialized. Ensure you performed the hardware reset sequence correctly. Many libraries forget to pull INT low before reset.