641 lines
18 KiB
C++
641 lines
18 KiB
C++
/**
|
|
*
|
|
* @license MIT License
|
|
*
|
|
* Copyright (c) 2022 lewis he
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
* @file TouchDrvGT911.tpp
|
|
* @author Lewis He (lewishe@outlook.com)
|
|
* @date 2023-04-12
|
|
*
|
|
*/
|
|
#pragma once
|
|
|
|
#include "REG/GT911Constants.h"
|
|
#include "TouchDrvInterface.hpp"
|
|
#include "SensorCommon.tpp"
|
|
|
|
|
|
#if defined(ARDUINO_ARCH_NRF52)
|
|
// NRF52840 I2C BUFFER : 64 Bytes ,
|
|
#warning "NRF Platform I2C Buffer expansion is not implemented , GT911 requires at least 188 bytes to read all configurations"
|
|
#endif
|
|
|
|
typedef struct GT911_Struct {
|
|
uint8_t trackID;
|
|
int16_t x;
|
|
int16_t y;
|
|
int16_t size;
|
|
} GT911Point_t;
|
|
|
|
|
|
#define LOW_LEVEL_QUERY 0x03
|
|
#define HIGH_LEVEL_QUERY 0x04
|
|
|
|
class TouchDrvGT911 :
|
|
public TouchDrvInterface,
|
|
public SensorCommon<TouchDrvGT911>
|
|
{
|
|
friend class SensorCommon<TouchDrvGT911>;
|
|
public:
|
|
|
|
|
|
#if defined(ARDUINO)
|
|
TouchDrvGT911(PLATFORM_WIRE_TYPE &w,
|
|
int sda = DEFAULT_SDA,
|
|
int scl = DEFAULT_SCL,
|
|
uint8_t addr = GT911_SLAVE_ADDRESS_H)
|
|
{
|
|
__wire = &w;
|
|
__sda = sda;
|
|
__scl = scl;
|
|
__rst = SENSOR_PIN_NONE;
|
|
__irq = SENSOR_PIN_NONE;
|
|
__addr = addr;
|
|
}
|
|
#endif
|
|
|
|
TouchDrvGT911()
|
|
{
|
|
#if defined(ARDUINO)
|
|
__wire = &Wire;
|
|
__sda = DEFAULT_SDA;
|
|
__scl = DEFAULT_SCL;
|
|
#endif
|
|
__rst = SENSOR_PIN_NONE;
|
|
__irq = SENSOR_PIN_NONE;
|
|
__addr = GT911_SLAVE_ADDRESS_H;
|
|
}
|
|
|
|
~TouchDrvGT911()
|
|
{
|
|
deinit();
|
|
}
|
|
|
|
#if defined(ARDUINO)
|
|
bool begin(PLATFORM_WIRE_TYPE &w,
|
|
uint8_t addr = GT911_SLAVE_ADDRESS_H,
|
|
int sda = DEFAULT_SDA,
|
|
int scl = DEFAULT_SCL
|
|
)
|
|
{
|
|
return SensorCommon::begin(w, addr, sda, scl);
|
|
}
|
|
|
|
#elif defined(ESP_PLATFORM) && !defined(ARDUINO)
|
|
|
|
#if ((ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5,0,0)) && defined(CONFIG_SENSORLIB_ESP_IDF_NEW_API))
|
|
bool begin(i2c_master_bus_handle_t i2c_dev_bus_handle, uint8_t addr)
|
|
{
|
|
return SensorCommon::begin(i2c_dev_bus_handle, addr);
|
|
}
|
|
#else
|
|
bool begin(i2c_port_t port_num, uint8_t addr, int sda, int scl)
|
|
{
|
|
return SensorCommon::begin(port_num, addr, sda, scl);
|
|
}
|
|
#endif //ESP_IDF_VERSION
|
|
|
|
#endif
|
|
|
|
bool begin(uint8_t addr, iic_fptr_t readRegCallback, iic_fptr_t writeRegCallback)
|
|
{
|
|
return SensorCommon::begin(addr, readRegCallback, writeRegCallback);
|
|
}
|
|
|
|
|
|
void deinit()
|
|
{
|
|
// end();
|
|
}
|
|
|
|
|
|
void reset()
|
|
{
|
|
if (__rst != SENSOR_PIN_NONE) {
|
|
this->setGpioMode(__rst, OUTPUT);
|
|
this->setGpioLevel(__rst, HIGH);
|
|
delay(10);
|
|
}
|
|
if (__irq != SENSOR_PIN_NONE) {
|
|
this->setGpioMode(__irq, INPUT);
|
|
}
|
|
/*
|
|
* If you perform a software reset on a board without a reset pin connected,
|
|
* subsequent interrupt settings or re-writing of configurations will be invalid.
|
|
* For example, when debugging a LilyGo T-Deck, resetting the interrupt mode will
|
|
* be invalid after a software reset.
|
|
* */
|
|
// writeRegister(GT911_COMMAND, 0x02);
|
|
// writeCommand(0x02);
|
|
}
|
|
|
|
void sleep()
|
|
{
|
|
if (__irq != SENSOR_PIN_NONE) {
|
|
this->setGpioMode(__irq, OUTPUT);
|
|
this->setGpioLevel(__irq, LOW);
|
|
}
|
|
// writeRegister(GT911_COMMAND, 0x05);
|
|
writeCommand(0x05);
|
|
|
|
/*
|
|
* Depending on the chip and platform, setting it to input after removing sleep will affect power consumption.
|
|
* The chip platform determines whether
|
|
*
|
|
* * */
|
|
// if (__irq != SENSOR_PIN_NONE) {
|
|
// this->setGpioLevel(__irq, INPUT);
|
|
// }
|
|
}
|
|
|
|
|
|
|
|
void wakeup()
|
|
{
|
|
if (__irq != SENSOR_PIN_NONE) {
|
|
this->setGpioMode(__irq, OUTPUT);
|
|
this->setGpioLevel(__irq, HIGH);
|
|
delay(8);
|
|
this->setGpioMode(__irq, INPUT);
|
|
} else {
|
|
reset();
|
|
}
|
|
}
|
|
|
|
void idle()
|
|
{
|
|
|
|
}
|
|
|
|
uint8_t getSupportTouchPoint()
|
|
{
|
|
return 5;
|
|
}
|
|
|
|
uint8_t getPoint(int16_t *x_array, int16_t *y_array, uint8_t size = 1)
|
|
{
|
|
uint8_t buffer[39];
|
|
uint8_t touchPoint = 0;
|
|
GT911Point_t p[5];
|
|
|
|
if (!x_array || !y_array || size == 0)
|
|
return 0;
|
|
|
|
uint8_t val = readGT911(GT911_POINT_INFO);
|
|
|
|
bool haveKey = GT911_GET_HAVE_KEY(val);
|
|
// bool bufferStatus = GT911_GET_BUFFER_STATUS(val);
|
|
// log_i("REG:0x%X S:0X%d K:%d\n", val,bufferStatus,haveKey);
|
|
|
|
if (__homeButtonCb && haveKey) {
|
|
__homeButtonCb(__userData);
|
|
}
|
|
|
|
clearBuffer();
|
|
|
|
touchPoint = GT911_GET_POINT(val);
|
|
if (touchPoint == 0) {
|
|
return 0;
|
|
}
|
|
|
|
// GT911_POINT_1 0X814F
|
|
uint8_t write_buffer[2] = {0x81, 0x4F};
|
|
if (writeThenRead(write_buffer, SENSORLIB_COUNT(write_buffer),
|
|
buffer, 39) == DEV_WIRE_ERR) {
|
|
return 0;
|
|
}
|
|
|
|
for (uint8_t i = 0; i < size; i++) {
|
|
p[i].trackID = buffer[i * 8];
|
|
p[i].x = buffer[0x01 + i * 8] ;
|
|
p[i].x |= (buffer[0x02 + i * 8] << 8 );
|
|
p[i].y = buffer[0x03 + i * 8] ;
|
|
p[i].y |= (buffer[0x04 + i * 8] << 8);
|
|
p[i].size = buffer[0x05 + i * 8] ;
|
|
p[i].size |= (buffer[0x06 + i * 8] << 8) ;
|
|
|
|
x_array[i] = p[i].x;
|
|
y_array[i] = p[i].y;
|
|
}
|
|
|
|
#ifdef LOG_PORT
|
|
LOG_PORT.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------");
|
|
LOG_PORT.println("Touched [0]ID [0]Size [0]X [0]Y [1]ID [1]Size [1]X [1]Y [2]ID [2]Size [2]X [2]Y [3]ID [3]Size [3]X [3]Y [4]ID [4]Size [4]X [4]Y ");
|
|
LOG_PORT.print(touchPoint); LOG_PORT.print("\t");
|
|
for (int i = 0; i < size; ++i) {
|
|
LOG_PORT.print(p[i].trackID); LOG_PORT.print("\t");
|
|
LOG_PORT.print(p[i].size); LOG_PORT.print("\t");
|
|
LOG_PORT.print( p[i].x); LOG_PORT.print("\t");
|
|
LOG_PORT.print( p[i].y); LOG_PORT.print("\t");
|
|
}
|
|
LOG_PORT.println();
|
|
#endif
|
|
|
|
updateXY(touchPoint, x_array, y_array);
|
|
|
|
return touchPoint;
|
|
}
|
|
|
|
|
|
bool isPressed()
|
|
{
|
|
if (__irq != SENSOR_PIN_NONE) {
|
|
if (__irq_mode == FALLING) {
|
|
return this->getGpioLevel(__irq) == LOW;
|
|
} else if (__irq_mode == RISING ) {
|
|
return this->getGpioLevel(__irq) == HIGH;
|
|
} else if (__irq_mode == LOW_LEVEL_QUERY) {
|
|
return this->getGpioLevel(__irq) == LOW;
|
|
} else if (__irq_mode == HIGH_LEVEL_QUERY) {
|
|
return this->getGpioLevel(__irq) == HIGH;
|
|
}
|
|
}
|
|
return getPoint();
|
|
}
|
|
|
|
bool setInterruptMode(uint8_t mode)
|
|
{
|
|
// GT911_MODULE_SWITCH_1 0x804D
|
|
uint8_t val = readGT911(GT911_MODULE_SWITCH_1);
|
|
val &= 0XFC;
|
|
if (mode == FALLING) {
|
|
val |= 0x01;
|
|
} else if (mode == RISING ) {
|
|
val |= 0x00;
|
|
} else if (mode == LOW_LEVEL_QUERY ) {
|
|
val |= 0x02;
|
|
} else if (mode == HIGH_LEVEL_QUERY ) {
|
|
val |= 0x03;
|
|
}
|
|
__irq_mode = mode;
|
|
writeGT911(GT911_MODULE_SWITCH_1, val);
|
|
return reloadConfig();
|
|
}
|
|
|
|
/**
|
|
* @retval
|
|
* * 0x0: Rising edge trigger
|
|
* * 0x1: Falling edge trigger
|
|
* * 0x2: Low level query
|
|
* * 0x3: High level query
|
|
*/
|
|
uint8_t getInterruptMode()
|
|
{
|
|
uint8_t val = readGT911(GT911_MODULE_SWITCH_1);
|
|
// return val & 0x03;
|
|
val &= 0x03;
|
|
if (val == 0x00) {
|
|
__irq_mode = RISING;
|
|
} else if (val == 0x01) {
|
|
__irq_mode = FALLING;
|
|
} else if (val == 0x02) {
|
|
__irq_mode = LOW_LEVEL_QUERY;
|
|
} else if (val == 0x03) {
|
|
__irq_mode = HIGH_LEVEL_QUERY;
|
|
}
|
|
return val;
|
|
}
|
|
|
|
|
|
uint8_t getPoint()
|
|
{
|
|
// GT911_POINT_INFO 0X814E
|
|
uint8_t val = readGT911(GT911_POINT_INFO);
|
|
clearBuffer();
|
|
return GT911_GET_POINT(val);
|
|
}
|
|
|
|
|
|
uint32_t getChipID()
|
|
{
|
|
char product_id[4] = {0};
|
|
// GT911_PRODUCT_ID 0x8140
|
|
for (int i = 0; i < 4; ++i) {
|
|
product_id[i] = readGT911(GT911_PRODUCT_ID + i);
|
|
}
|
|
return atoi(product_id);
|
|
}
|
|
|
|
uint16_t getFwVersion()
|
|
{
|
|
uint8_t fw_ver[2] = {0};
|
|
// GT911_FIRMWARE_VERSION 0x8144
|
|
for (int i = 0; i < 2; ++i) {
|
|
fw_ver[i] = readGT911(GT911_FIRMWARE_VERSION + i);
|
|
}
|
|
return fw_ver[0] | (fw_ver[1] << 8);
|
|
}
|
|
|
|
uint8_t getConfigVersion()
|
|
{
|
|
return readGT911(GT911_CONFIG_VERSION);
|
|
}
|
|
|
|
|
|
bool getResolution(int16_t *x, int16_t *y)
|
|
{
|
|
uint8_t x_resolution[2] = {0}, y_resolution[2] = {0};
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
x_resolution[i] = readGT911(GT911_X_RESOLUTION + i);
|
|
}
|
|
for (int i = 0; i < 2; ++i) {
|
|
y_resolution[i] = readGT911(GT911_Y_RESOLUTION + i);
|
|
}
|
|
|
|
*x = x_resolution[0] | (x_resolution[1] << 8);
|
|
*y = y_resolution[0] | (y_resolution[1] << 8);
|
|
return true;
|
|
}
|
|
|
|
//Range : 5 ~ 15 ms
|
|
void updateRefreshRate(uint8_t rate_ms)
|
|
{
|
|
if ((rate_ms - 5) < 5) {
|
|
rate_ms = 5;
|
|
}
|
|
if (rate_ms > 15) {
|
|
rate_ms = 15;
|
|
}
|
|
rate_ms -= 5;
|
|
writeGT911(GT911_REFRESH_RATE, rate_ms);
|
|
reloadConfig();
|
|
}
|
|
|
|
uint8_t getRefreshRate()
|
|
{
|
|
uint8_t rate_ms = readGT911(GT911_REFRESH_RATE);
|
|
return rate_ms + GT911_BASE_REF_RATE ;
|
|
}
|
|
|
|
|
|
int getVendorID()
|
|
{
|
|
return readGT911(GT911_VENDOR_ID);
|
|
}
|
|
|
|
|
|
const char *getModelName()
|
|
{
|
|
return "GT911";
|
|
}
|
|
|
|
void setGpioCallback(gpio_mode_fptr_t mode_cb,
|
|
gpio_write_fptr_t write_cb,
|
|
gpio_read_fptr_t read_cb)
|
|
{
|
|
SensorCommon::setGpioModeCallback(mode_cb);
|
|
SensorCommon::setGpioWriteCallback(write_cb);
|
|
SensorCommon::setGpioReadCallback(read_cb);
|
|
}
|
|
|
|
void setHomeButtonCallback(home_button_callback_t cb, void *user_data)
|
|
{
|
|
__homeButtonCb = cb;
|
|
__userData = user_data;
|
|
}
|
|
|
|
bool writeConfig(const uint8_t *config_buffer, size_t buffer_size)
|
|
{
|
|
setRegAddressLength(2);
|
|
int err = writeRegister(GT911_CONFIG_VERSION, (uint8_t *)config_buffer, buffer_size);
|
|
setRegAddressLength(1);
|
|
return err == DEV_WIRE_NONE;
|
|
}
|
|
|
|
uint8_t *loadConfig(size_t *output_size, bool print_out = false)
|
|
{
|
|
*output_size = 0;
|
|
uint8_t *buffer = (uint8_t * )malloc(GT911_REG_LENGTH * sizeof(uint8_t));
|
|
if (!buffer)return NULL;
|
|
uint8_t write_buffer[2] = {highByte(GT911_CONFIG_VERSION), lowByte(GT911_CONFIG_VERSION)};
|
|
if (writeThenRead(write_buffer, SENSORLIB_COUNT(write_buffer), buffer, GT911_REG_LENGTH) == DEV_WIRE_ERR) {
|
|
free(buffer);
|
|
return NULL;
|
|
}
|
|
if (print_out) {
|
|
printf("const unsigned char config[186] = {");
|
|
for (int i = 0; i < GT911_REG_LENGTH; ++i) {
|
|
if ( (i % 8) == 0) {
|
|
printf("\n");
|
|
}
|
|
printf("0x%02X", buffer[i]);
|
|
if ((i + 1) < GT911_REG_LENGTH) {
|
|
printf(",");
|
|
}
|
|
}
|
|
printf("};\n");
|
|
}
|
|
*output_size = GT911_REG_LENGTH;
|
|
return buffer;
|
|
}
|
|
|
|
bool reloadConfig()
|
|
{
|
|
uint8_t buffer[GT911_REG_LENGTH] = {highByte(GT911_CONFIG_VERSION), lowByte(GT911_CONFIG_VERSION)};
|
|
if (writeThenRead(buffer, 2, buffer, GT911_REG_LENGTH - 2) == DEV_WIRE_ERR) {
|
|
return false;
|
|
}
|
|
|
|
uint8_t check_sum = 0;
|
|
for (int i = 0; i < (GT911_REG_LENGTH - 2 ); i++) {
|
|
check_sum += buffer[i];
|
|
}
|
|
check_sum = (~check_sum) + 1;
|
|
log_d("reloadConfig check_sum : 0x%X\n", check_sum);
|
|
writeGT911(GT911_CONFIG_CHKSUM, check_sum);
|
|
writeGT911(GT911_CONFIG_FRESH, 0x01);
|
|
return true;
|
|
}
|
|
|
|
void dumpRegister()
|
|
{
|
|
size_t output_size = 0;
|
|
uint8_t *buffer = loadConfig(&output_size, true);
|
|
if (output_size == 0) {
|
|
return;
|
|
}
|
|
|
|
if (buffer == NULL)return;
|
|
printf("----------Dump register------------\n");
|
|
for (size_t i = 0; i < output_size; ++i) {
|
|
printf("[%d] REG: 0x%X : 0x%02X\n", i, GT911_CONFIG_VERSION + i, buffer[i]);
|
|
}
|
|
free(buffer);
|
|
}
|
|
|
|
// Range : 1~5
|
|
void setMaxTouchPoint(uint8_t num)
|
|
{
|
|
if (num < 1)num = 1;
|
|
if (num > 5) num = 5;
|
|
writeGT911(GT911_TOUCH_NUMBER, num);
|
|
reloadConfig();
|
|
}
|
|
|
|
uint8_t getMaxTouchPoint()
|
|
{
|
|
uint8_t num = readGT911(GT911_TOUCH_NUMBER);
|
|
return num & 0x0F;
|
|
}
|
|
|
|
private:
|
|
|
|
uint8_t readGT911(uint16_t cmd)
|
|
{
|
|
uint8_t value = 0x00;
|
|
uint8_t write_buffer[2] = {highByte(cmd), lowByte(cmd)};
|
|
writeThenRead(write_buffer, SENSORLIB_COUNT(write_buffer),
|
|
&value, 1);
|
|
return value;
|
|
}
|
|
|
|
int writeGT911(uint16_t cmd, uint8_t value)
|
|
{
|
|
uint8_t write_buffer[3] = {highByte(cmd), lowByte(cmd), value};
|
|
return writeBuffer(write_buffer, SENSORLIB_COUNT(write_buffer));
|
|
}
|
|
|
|
|
|
void writeCommand(uint8_t command)
|
|
{
|
|
// GT911_COMMAND 0x8040
|
|
uint8_t write_buffer[3] = {0x80, 0x40, command};
|
|
writeBuffer(write_buffer, SENSORLIB_COUNT(write_buffer));
|
|
}
|
|
|
|
void inline clearBuffer()
|
|
{
|
|
writeGT911(GT911_POINT_INFO, 0x00);
|
|
}
|
|
|
|
bool probeAddress()
|
|
{
|
|
const uint8_t device_address[2] = {GT911_SLAVE_ADDRESS_L, GT911_SLAVE_ADDRESS_H};
|
|
for (size_t i = 0; i < SENSORLIB_COUNT(device_address); ++i) {
|
|
__addr = device_address[i];
|
|
for (int retry = 0; retry < 3; ++retry) {
|
|
if (getChipID() == GT911_DEV_ID) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
bool initImpl()
|
|
{
|
|
int16_t x = 0, y = 0;
|
|
|
|
if (__rst == SENSOR_PIN_NONE) {
|
|
// Automatically determine the current device
|
|
// address when using the reset pin without connection
|
|
if (!probeAddress()) {
|
|
return false;
|
|
}
|
|
log_i("Probe address is : 0x%X", __addr);
|
|
|
|
// Reset Config
|
|
reset();
|
|
|
|
this->setGpioMode(__irq, INPUT);
|
|
|
|
} else if (__addr == GT911_SLAVE_ADDRESS_H &&
|
|
__rst != SENSOR_PIN_NONE &&
|
|
__irq != SENSOR_PIN_NONE) {
|
|
|
|
log_i("GT911 using 0x28 address!");
|
|
|
|
this->setGpioMode(__rst, OUTPUT);
|
|
this->setGpioMode(__irq, OUTPUT);
|
|
|
|
this->setGpioLevel(__rst, LOW);
|
|
this->setGpioLevel(__irq, HIGH);
|
|
delayMicroseconds(120);
|
|
this->setGpioLevel(__rst, HIGH);
|
|
delay(18);
|
|
this->setGpioMode(__irq, INPUT);
|
|
|
|
} else if (__addr == GT911_SLAVE_ADDRESS_L &&
|
|
__rst != SENSOR_PIN_NONE &&
|
|
__irq != SENSOR_PIN_NONE) {
|
|
|
|
log_i("GT911 using 0xBA address!");
|
|
|
|
this->setGpioMode(__rst, OUTPUT);
|
|
this->setGpioMode(__irq, OUTPUT);
|
|
|
|
this->setGpioLevel(__rst, LOW);
|
|
this->setGpioLevel(__irq, LOW);
|
|
delayMicroseconds(120);
|
|
this->setGpioLevel(__rst, HIGH);
|
|
delay(18);
|
|
this->setGpioMode(__irq, INPUT);
|
|
|
|
}
|
|
|
|
// For variants where the GPIO is controlled by I2C, a delay is required here
|
|
delay(20);
|
|
|
|
__chipID = getChipID();
|
|
log_i("Product id:%ld", __chipID);
|
|
|
|
if (__chipID != GT911_DEV_ID) {
|
|
log_i("Not find device GT911");
|
|
return false;
|
|
}
|
|
log_i("Firmware version: 0x%x", getFwVersion());
|
|
getResolution(&x, &y);
|
|
log_i("Resolution : X = %d Y = %d", x, y);
|
|
log_i("Vendor id:%d", getVendorID());
|
|
log_i("Refresh Rate:%d ms", getRefreshRate());
|
|
log_i("MaxTouchPoint:%d", getMaxTouchPoint());
|
|
|
|
/*
|
|
* For the ESP32 platform, the default buffer is 128.
|
|
* Need to re-apply for a larger buffer to fully read the configuration table.
|
|
* */
|
|
if (!this->reallocBuffer(GT911_REG_LENGTH + 2 )) {
|
|
log_e("realloc i2c buffer failed !");
|
|
return false;
|
|
}
|
|
|
|
// Get the default interrupt trigger mode of the current screen
|
|
getInterruptMode();
|
|
|
|
return true;
|
|
}
|
|
|
|
int getReadMaskImpl()
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
protected:
|
|
int __irq_mode;
|
|
};
|
|
|
|
|
|
|