touch/TouchDrvCSTXXX.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_TOUCH_CSTXXX
 
#include "touch/TouchDrvCST226.hpp"
#include "touch/TouchDrvCST816.hpp"
#include "touch/TouchDrvCST92xx.hpp"
#include "touch/TouchDrvCST3530.hpp"
 
static constexpr uint8_t CSTXXX_SLAVE_ADDRESS = (0x15);
static constexpr uint8_t CST328_SLAVE_ADDRESS = (0x1A);
 
enum TouchDrvType {
    TouchDrv_CST226,
    TouchDrv_CST8XX,
    TouchDrv_CST92XX,
    TouchDrv_CST3530,
    TouchDrv_UNKNOWN,
};
 
class TouchDrvCSTXXX : public TouchDrvInterface
{
public:
    TouchDrvCSTXXX();
 
    ~TouchDrvCSTXXX() = default;
 
// *INDENT-OFF*
    void setTouchDrvModel(TouchDrvType model);
 
#if defined(ARDUINO)
    bool begin(TwoWire &wire, uint8_t addr, int sda, int scl) override;
#elif defined(ESP_PLATFORM)
#if defined(SENSORLIB_USE_I2C_LEGACY)
    bool begin(i2c_port_t port_num, uint8_t addr, int sda = -1, int scl = -1) override;
#else
    bool begin(i2c_master_bus_handle_t handle, uint8_t addr) override;
#endif  // ESP_PLATFORM
#endif  // ARDUINO
 
    bool begin(SensorCommCustom::CustomCallback callback,
               SensorCommCustomHal::CustomHalCallback hal_callback,
               uint8_t addr) override;
 
    void reset() override;
 
    void sleep() override;
 
    void wakeup() override;
 
    const TouchPoints& getTouchPoints() override;
 
    bool isPressed(uint32_t filter_ms = 0) override;
 
    const char *getModelName() override;
 
    uint32_t getChipID() override;
 
    void setCenterButtonCoordinate(int16_t x, int16_t y) override;
 
    void setHomeButtonCallback(TouchDrvInterface::HomeButtonCallback callback, void *user_data = NULL) override;
 
    void disableAutoSleep();
 
    void enableAutoSleep();
 
    void setSwapXY(bool swap) override;
 
    void setMirrorXY(bool mirrorX, bool mirrorY) override;
 
    void setMaxCoordinates(uint16_t x, uint16_t y) override;
 
    uint8_t getSupportTouchPoint() override;
 
    void getResolution(uint16_t &x, uint16_t &y) override;
 
    uint16_t getResolutionX() override;
 
    uint16_t getResolutionY() override;
 
// *INDENT-ON*
 
private:
 
    bool initImpl(uint8_t) override
    {
        return false;
    }
 
    using DriverCreator = std::unique_ptr<TouchDrvInterface> (*)();
 
    static constexpr uint8_t driverCreatorMaxNum = 4;
    static DriverCreator driverCreators[driverCreatorMaxNum];
 
    std::unique_ptr<TouchDrvInterface> createDriver(TouchDrvType type)
    {
        if (type < driverCreatorMaxNum) {
            return driverCreators[type]();
        }
        return nullptr;
    }
 
    template<typename... Args>
    bool beginImpl(Args&&... args)
    {
        for (int i = (_touchType == TouchDrv_UNKNOWN) ? 0 : _touchType;
                i < driverCreatorMaxNum; ++i) {
            _drv = createDriver(static_cast<TouchDrvType>(i));
            setupDriver();
            if (_drv && _drv->begin(std::forward<Args>(args)...)) {
                _touchType = static_cast<TouchDrvType>(i);
                return true;
            }
        }
        _touchType = TouchDrv_UNKNOWN;
        return false;
    }
 
    static constexpr size_t TOUCH_DRV_TYPE_VALID_COUNT = TouchDrv_UNKNOWN;
 
    static_assert(sizeof(driverCreators) / sizeof(driverCreators[0]) == TOUCH_DRV_TYPE_VALID_COUNT,
                  "driverCreators size mismatch");
 
    void setupDriver();
    TouchDrvType                        _touchType;
    std::unique_ptr<TouchDrvInterface>  _drv;
};
 
#endif