touch/TouchDrvInterface.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_TOUCH_COMMON
 
#include "platform/comm/I2CDeviceWithHal.hpp"
#include "TouchPoints.hpp"
 
class TouchDrvInterface : public I2CDeviceWithHal
{
public:
 
    struct TouchPinsCfg {
        int rstPin;             // Reset pin number, -1 if not used
        int irqPin;             // Interrupt pin number, -1 if not used
        int rstActiveLevel;     // Active level for reset pin (HIGH or LOW)
        int irqTriggerLevel;    // Trigger level for interrupt pin (HIGH or LOW)
        int rstHoldTimeMs;      // Minimum hold time for reset signal in milliseconds
        int rstReleaseTimeMs;   // Minimum release time after reset in milliseconds
    };
 
    struct TouchConfig {
        bool swapXY;            // Whether to swap X and Y coordinates
        bool mirrorX;           // Whether to mirror X coordinates
        bool mirrorY;           // Whether to mirror Y coordinates
        bool scalingEnabled;    // Whether scaling is enabled
        uint16_t xMax;          // Maximum X coordinate value from the hardware
        uint16_t yMax;          // Maximum Y coordinate value from the hardware
        uint16_t resolutionX;   // Physical resolution of the touch panel (used for scaling)
        uint16_t resolutionY;   // Physical resolution of the touch panel (used for scaling)
        float scaleX;           // Scaling factor for X coordinates
        float scaleY;           // Scaling factor for Y coordinates
    };
 
    using HomeButtonCallback = void(*)(void *user_data);
 
    TouchDrvInterface() : _halModeCallback(nullptr),
        _halWriteCallback(nullptr), _halReadCallback(nullptr),
        _chipID(0x00), _HButtonCallback(nullptr), _userData(nullptr), _maxTouchPoints(0),
        _center_btn_x(-1), _center_btn_y(-1),
        _lastPulse(0),  _pinsCfg({-1, -1, LOW, LOW, 10, 10}),
               _touchConfig({false, false, false, false, 0, 0, 0, 0, 1.0f, 1.0f})
    {
    }
 
    virtual ~TouchDrvInterface() = default;
 
// *INDENT-OFF*
#if defined(ARDUINO)
    virtual bool begin(TwoWire &wire, uint8_t addr, int sda = -1, int scl = -1)
    {
        return I2CDeviceWithHal::begin(wire, addr, sda, scl);
    }
 
#elif defined(ESP_PLATFORM)
 
#if defined(SENSORLIB_USE_I2C_LEGACY)
 
    virtual bool begin(i2c_port_t port_num, uint8_t addr, int sda, int scl)
    {
        return I2CDeviceWithHal::begin(port_num, addr, sda, scl);
    }
 
#else
 
    virtual bool begin(i2c_master_bus_handle_t handle, uint8_t addr)
    {
        return I2CDeviceWithHal::begin(handle, addr);
    }
 
#endif  //SENSORLIB_USE_I2C_LEGACY
#endif  //ARDUINO
 
    virtual bool begin(SensorCommCustom::CustomCallback callback,
                       SensorCommCustomHal::CustomHalCallback hal_callback,
                       uint8_t addr)
    {
        return I2CDeviceWithHal::begin(callback, hal_callback, addr);
    }
 
    virtual void setGpioCallback(SensorHalCustom::CustomMode mode_cb, 
                                SensorHalCustom::CustomWrite write_cb, 
                                SensorHalCustom::CustomRead read_cb) {
        _halModeCallback  = mode_cb;
        _halWriteCallback = write_cb;
        _halReadCallback  = read_cb;
    }
 
    virtual uint8_t getSupportTouchPoint() {
        return _maxTouchPoints;
    }
 
    virtual void getResolution(uint16_t &x, uint16_t &y) {
        x = _touchConfig.resolutionX;
        y = _touchConfig.resolutionY;
    }
 
    virtual uint16_t getResolutionX() {
        return _touchConfig.resolutionX;
    }
 
    virtual uint16_t getResolutionY() {
        return _touchConfig.resolutionY;
    }
 
    virtual bool initImpl(uint8_t param) = 0;
 
    virtual void reset()
    {
        if (_pinsCfg.rstPin != -1) {
            // Perform hardware reset using the reset pin
            hal->digitalWrite(_pinsCfg.rstPin, _pinsCfg.rstActiveLevel);
            hal->delay(_pinsCfg.rstHoldTimeMs);
            hal->digitalWrite(_pinsCfg.rstPin, !_pinsCfg.rstActiveLevel);
            hal->delay(_pinsCfg.rstReleaseTimeMs);
        }
        // If no reset pin is available, derived classes can override this method to implement a software reset if supported.
    }
 
    virtual void sleep() = 0;
 
    virtual void wakeup()
    {
        reset();
    }
 
    virtual uint8_t getPoint(int16_t *x_array, int16_t *y_array, uint8_t get_point = 1) __attribute__((deprecated("use getTouchPoints instead of getPoint")))
    {
        TouchPoints data = getTouchPoints();
 
        if (x_array == nullptr || y_array == nullptr) {
            return data.getPointCount();
        }
        if (data.hasPoints()) {
            uint8_t pointsToCopy = (get_point < data.getPointCount()) ? get_point : data.getPointCount();
            for (int i = 0; i < pointsToCopy; i++) {
               const TouchPoint &pt = data.getPoint(i);
                x_array[i] = pt.x;
                y_array[i] = pt.y;
            }
        }
        return data.getPointCount();
    }
 
    virtual const TouchPoints& getTouchPoints() = 0;
 
    virtual bool isPressed(uint32_t filter_ms = 0)
    {
        if (_pinsCfg.irqPin != -1) {
            if (hal->digitalRead(_pinsCfg.irqPin) == _pinsCfg.irqTriggerLevel) {
                if(filter_ms == 0){
                    return true;
                }
                uint32_t now = hal->millis();
                if (now - _lastPulse > filter_ms) {
                    _lastPulse = now;
                    return true;
                }
            }
            return false;
        }
        return getTouchPoints().hasPoints();
    }
 
    virtual const char *getModelName() = 0;
 
    virtual uint32_t getChipID() {
        return _chipID;
    }
 
    virtual void setPins(int rst, int irq) {
        _pinsCfg.irqPin = irq;
        _pinsCfg.rstPin = rst;
    }
 
    virtual const TouchPinsCfg& getTouchPinsCfg() const { return _pinsCfg; }
 
    virtual void setSwapXY(bool swap) {
        _touchConfig.swapXY = swap;
    }
 
    virtual bool isSwapXY() const { return _touchConfig.swapXY; }
 
    virtual void setMirrorXY(bool mirrorX, bool mirrorY) {
        _touchConfig.mirrorX = mirrorX;
        _touchConfig.mirrorY = mirrorY;
    }
 
    virtual bool isMirrorX() const { return _touchConfig.mirrorX; }
 
    virtual bool isMirrorY() const { return _touchConfig.mirrorY; }
 
    virtual void setMaxCoordinates(uint16_t x, uint16_t y) {
        _touchConfig.xMax = x;
        _touchConfig.yMax = y;
    }
 
    virtual void getMaxCoordinates(uint16_t &x, uint16_t &y) {
        x = _touchConfig.xMax;
        y = _touchConfig.yMax;
    }
 
    virtual uint16_t getMaxX() { return _touchConfig.xMax; }
 
    virtual uint16_t getMaxY() { return _touchConfig.yMax; }
 
    virtual bool isScalingEnabled() { return _touchConfig.scalingEnabled; }
 
    virtual void setResolution(uint16_t width, uint16_t height) {
        _touchConfig.resolutionX = width;
        _touchConfig.resolutionY = height;
    }
 
    virtual void setTargetResolution(uint16_t width, uint16_t height) {
        if (_touchConfig.resolutionX == 0 || _touchConfig.resolutionY == 0) {
            _touchConfig.scaleX = _touchConfig.scaleY = 1.0f;
            _touchConfig.scalingEnabled = false;
        } else {
            _touchConfig.scaleX = (float)width / _touchConfig.resolutionX;
            _touchConfig.scaleY = (float)height / _touchConfig.resolutionY;
            _touchConfig.scalingEnabled = true;
        }
        _touchConfig.xMax = width;
        _touchConfig.yMax = height;
    }
 
    virtual void updateXY(TouchPoints &points) const
    {
        uint8_t count = points.getPointCount();
        if (count == 0){
            return;
        }
        for (uint8_t i = 0; i < count; ++i) {
            TouchPoint &pt = points.getPoint(i);
 
            // Swap XY
            if (_touchConfig.swapXY) {
                uint16_t tmp = pt.x;
                pt.x = pt.y;
                pt.y = tmp;
            }
 
            // Apply scaling if target resolution set
            if (_touchConfig.scalingEnabled) {
                pt.x = static_cast<uint16_t>(pt.x * _touchConfig.scaleX + 0.5f);
                pt.y = static_cast<uint16_t>(pt.y * _touchConfig.scaleY + 0.5f);
            }
 
            // Mirror X
            if (_touchConfig.mirrorX && _touchConfig.xMax > 0) {
                pt.x = _touchConfig.xMax - pt.x;
            }
 
            // Mirror Y
            if (_touchConfig.mirrorY && _touchConfig.yMax > 0) {
                pt.y = _touchConfig.yMax - pt.y;
            }
 
            // Clamp to display bounds
            if(_touchConfig.xMax != 0) {
                if (pt.x > _touchConfig.xMax) {
                    pt.x = _touchConfig.xMax;
                }
            }
            if(_touchConfig.yMax != 0) {
                if (pt.y > _touchConfig.yMax) {
                    pt.y = _touchConfig.yMax;
                }
            }
        }
    }
 
    virtual void setHomeButtonCallback(HomeButtonCallback cb, void *user_data) {
        _HButtonCallback = cb;
        _userData = user_data;
    }
 
    virtual void setCenterButtonCoordinate(int16_t x, int16_t y) {
        _center_btn_x = x;
        _center_btn_y = y;
    }
 
// *INDENT-ON*
 
protected:
 
    SensorHalCustom::CustomMode  _halModeCallback;                
    SensorHalCustom::CustomWrite _halWriteCallback;               
    SensorHalCustom::CustomRead  _halReadCallback;                
 
    uint32_t _chipID;              
    HomeButtonCallback _HButtonCallback; 
    void *_userData;               
    uint8_t _maxTouchPoints;       
    int16_t _center_btn_x;         
    int16_t _center_btn_y;         
    uint32_t _lastPulse;           
    TouchPinsCfg _pinsCfg;        
    TouchConfig _touchConfig;        
    TouchPoints _touchPoints;      
 
private:
    virtual void afterCommReady() override
    {
        if (_halModeCallback) {
            hal->setCustomMode(_halModeCallback);
        }
        if (_halWriteCallback) {
            hal->setCustomWrite(_halWriteCallback);
        }
        if (_halReadCallback) {
            hal->setCustomRead(_halReadCallback);
        }
        initGpioPins();
    }
 
    virtual void initGpioPins()
    {
        if (_pinsCfg.rstPin != -1) {
            hal->pinMode(_pinsCfg.rstPin, OUTPUT);
        }
        if (_pinsCfg.irqPin != -1) {
            hal->pinMode(_pinsCfg.irqPin, INPUT);
        }
        reset();
    }
};
 
#endif