222 lines
6.3 KiB
C++
222 lines
6.3 KiB
C++
/**
|
|
*
|
|
* @license MIT License
|
|
*
|
|
* Copyright (c) 2022 micky
|
|
*
|
|
* 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 TouchLibZTW622.tpp
|
|
* @author Micky (513673326@qq.com)
|
|
* @date 2022-10-24
|
|
*
|
|
*/
|
|
|
|
#if defined(ARDUINO)
|
|
#include <Arduino.h>
|
|
#endif
|
|
#include "REG/ZTW622Constants.h"
|
|
#include "TouchLibCommon.tpp"
|
|
#include "TouchLibInterface.hpp"
|
|
|
|
class TouchLibZTW622 : public TouchLibCommon<TouchLibZTW622>, public TouchLibInterface {
|
|
friend class TouchLibCommon<TouchLibZTW622>;
|
|
|
|
public:
|
|
#if defined(ARDUINO)
|
|
TouchLibZTW622(TwoWire &w, int sda = SDA, int scl = SCL, uint8_t addr = ZTW622_SLAVE_ADDRESS, int rst = -1) {
|
|
__wire = &w;
|
|
__sda = sda;
|
|
__scl = scl;
|
|
__addr = addr;
|
|
__rst = rst;
|
|
}
|
|
#endif
|
|
|
|
TouchLibZTW622() {
|
|
#if defined(ARDUINO)
|
|
__wire = &Wire;
|
|
__sda = SDA;
|
|
__scl = SCL;
|
|
__rst = -1;
|
|
#endif
|
|
__addr = ZTW622_SLAVE_ADDRESS;
|
|
}
|
|
|
|
~TouchLibZTW622() {
|
|
log_i("~TouchLibZTW622");
|
|
deinit();
|
|
}
|
|
|
|
bool init() {
|
|
int ret = 0;
|
|
begin();
|
|
ret = this->writeRegister((uint16_t)(0x000C), (uint16_t)(0x0001));
|
|
if (ret) {
|
|
log_i("power sequence error (vendor cmd enable)");
|
|
return false;
|
|
}
|
|
/* Read the value of the 0xCC00 address, the ID of the chip */
|
|
ret = this->readRegister((uint16_t)(0xCC00), (uint8_t *)&chip_code, 2);
|
|
if (ret) {
|
|
log_i("fail to read chip code");
|
|
return false;
|
|
}
|
|
log_i("chip code = 0x%x\n", chip_code);
|
|
|
|
ret = this->writeRegister((uint8_t)(0xC0), (uint8_t)(0x04));
|
|
if (ret) {
|
|
log_i("power sequence error (intn clear)");
|
|
return false;
|
|
}
|
|
|
|
ret = this->writeRegister((uint16_t)(0xC002), (uint16_t)(0x0001));
|
|
if (ret) {
|
|
log_i("power sequence error (nvm init)");
|
|
return false;
|
|
}
|
|
|
|
ret = this->writeRegister((uint16_t)(0xC001), (uint16_t)(0x0001));
|
|
if (ret) {
|
|
log_i("power sequence error (program start)");
|
|
return false;
|
|
}
|
|
delay(150);
|
|
|
|
ret = this->readRegister(ZINITIX_FIRMWARE_VERSION, (uint8_t *)&firmware_version, 2);
|
|
if (ret) {
|
|
log_i("fail to read FIRMWARE_VERSION");
|
|
return false;
|
|
}
|
|
/* 0x07 version cannot wake up from sleep */
|
|
if (firmware_version != 0x07)
|
|
ztw622_has_sleep_function = true;
|
|
log_i("touch FW version = %d\r\n", firmware_version);
|
|
|
|
ret = this->readRegister(ZINITIX_DATA_VERSION_REG, (uint8_t *)®_data_version, 2);
|
|
if (ret) {
|
|
log_i("fail to read reg version");
|
|
return false;
|
|
}
|
|
log_i("touch register version = %d\r\n", reg_data_version);
|
|
|
|
if (reg_data_version >= 3)
|
|
ztw622_has_palm_coverage_detection = true;
|
|
|
|
ret = this->writeRegister(ZINITIX_INITIAL_TOUCH_MODE, (uint16_t)(0x0001));
|
|
if (ret) {
|
|
log_i("fail to write inital touch mode");
|
|
return false;
|
|
}
|
|
ret = this->writeRegister(ZINITIX_TOUCH_MODE, (uint16_t)(0x0001));
|
|
if (ret) {
|
|
log_i("fail to write touh mode");
|
|
return false;
|
|
}
|
|
ret = this->writeRegister(ZINITIX_SUPPORTED_FINGER_NUM, (uint16_t)(0x0001));
|
|
if (ret) {
|
|
log_i("fail to write finger num");
|
|
return false;
|
|
}
|
|
|
|
ret = this->writeRegister(ZINITIX_X_RESOLUTION, (uint16_t)(0x0001));
|
|
if (ret) {
|
|
log_i("fail to write finger num");
|
|
return false;
|
|
}
|
|
ret = this->writeRegister(ZINITIX_Y_RESOLUTION, (uint16_t)(0x0001));
|
|
if (ret) {
|
|
log_i("fail to write finger num");
|
|
return false;
|
|
}
|
|
ret = this->writeRegister((uint8_t)(0x00), (uint8_t)(0x06));
|
|
if (ret) {
|
|
log_i("fail to write finger num");
|
|
return false;
|
|
}
|
|
for (int i = 0; i < 10; i++) {
|
|
this->writeRegister((uint8_t)(0x00), (uint8_t)(0x03));
|
|
delay(10);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
void deinit() { end(); }
|
|
|
|
bool enableSleep() { return 1; }
|
|
|
|
bool read() {
|
|
this->readRegister(ZINITIX_POINT_STATUS_REG, raw_data, sizeof(raw_data));
|
|
|
|
// for (int i = 0; i < 16; i++) {
|
|
// Serial.printf("[%d]0x%02X ", i, raw_data[i]);
|
|
// }
|
|
// Serial.println();
|
|
|
|
// this->readRegister(POINT_COUNT_TIMESTAMP_REG, &raw_data[2], 2);
|
|
|
|
// if ((raw_data[3] << 8 | raw_data[2]) != 0) {
|
|
// this->writeRegister((uint8_t)(ZINITIX_CLEAR_INT_CMD >> 8), (uint8_t)(ZINITIX_CLEAR_INT_CMD & 0xFF));
|
|
// return 1;
|
|
// }
|
|
// return 0;
|
|
return (raw_data[1] & BIT_POINT_DETECTED);
|
|
}
|
|
|
|
uint8_t getPointNum() { return (raw_data[3] << 8 | raw_data[2]); }
|
|
|
|
TP_Point getPoint(uint8_t n) {
|
|
if (n > 4) {
|
|
log_i("The parameter range of getPoint is between 0 and 4.");
|
|
return TP_Point(0, 0, 0, 0, 0, 0);
|
|
}
|
|
|
|
TP_Point t;
|
|
uint16_t point_reg[5] = ZINITIX_POINTS_REG;
|
|
uint16_t offset = point_reg[n] - ZINITIX_POINT_STATUS_REG;
|
|
|
|
t.id = n;
|
|
t.x = raw_data[offset] + (raw_data[offset + 1] << 8);
|
|
t.y = raw_data[offset + 2] + (raw_data[offset + 3] << 8);
|
|
t.pressure = raw_data[offset + 4];
|
|
t.state = raw_data[offset + 5];
|
|
|
|
if (rotation == 0) {
|
|
} else if (rotation == 1) {
|
|
uint16_t tmp = t.x;
|
|
t.x = t.y;
|
|
t.y = tmp;
|
|
}
|
|
return t;
|
|
}
|
|
void setRotation(uint8_t r) { rotation = r % 4; }
|
|
|
|
uint8_t getRotation() { return 1; }
|
|
|
|
protected:
|
|
bool initImpl() { return true; }
|
|
uint8_t raw_data[33] = {0};
|
|
uint8_t rotation = 0;
|
|
bool ztw622_has_sleep_function = false;
|
|
bool ztw622_has_palm_coverage_detection = false;
|
|
uint16_t chip_code = 0;
|
|
uint16_t firmware_version = 0;
|
|
uint16_t reg_data_version = 0;
|
|
}; |