unit_PAJ7620U2.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_GESTURE_UNIT_PAJ7620U2_HPP
#define M5_UNIT_GESTURE_UNIT_PAJ7620U2_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <array>
#include <memory>
 
namespace m5 {
namespace unit {
 
namespace paj7620u2 {
enum class Gesture : uint16_t {
    None,                         
    Up               = 1U << 0,   
    Down             = 1U << 1,   
    Left             = 1U << 2,   
    Right            = 1U << 3,   
    Forward          = 1U << 4,   
    Backward         = 1U << 5,   
    Clockwise        = 1U << 6,   
    CounterClockwise = 1U << 7,   
    Wave             = 1U << 8,   
    Approach         = 1U << 9,   
    HasObject        = 1U << 10,  
    WakeupTrigger    = 1U << 11,  
    Confirm          = 1U << 12,  
    Abort            = 1U << 13,  
    Reserve          = 1U << 14,  
    NoObject         = 1U << 15,  
};
 
enum class Mode : uint8_t {
    Gesture,    
    Proximity,  
    Cursor,     
};
 
enum class Frequency : int8_t {
    Unknown = -1,  
    Normal,        
    Gaming,        
};
 
inline float idle_time_to_hz(const uint16_t idle_time)
{
    return 31250.0f / (77 + idle_time);
}
 
inline uint16_t hz_to_idle_time(const float hz)
{
    if (hz <= 0.0f) {
        return 0;
    }
    float v = 31250.0f / hz - 77.0f;
    if (v < 0.0f) {
        return 0;
    }
    if (v > 65535.0f) {
        return 65535;
    }
    return static_cast<uint16_t>(v + 0.5f);
}
 
struct Data {
    Data()
    {
    }
    // Common
    // [0,1]:gesture
    // Proximity
    // [2]:proximity [3]:approach
    // Cursor
    // [2,3]:X [4,5]:Y
    std::array<uint8_t, 2 + 4> raw{};  
    Gesture data_gesture{};            
    Mode data_mode{};                  
    union {
        struct {
            uint8_t proximity_brightness;  
            bool proximity_approach;       
        };
        struct {
            uint16_t cursor_x{}, cursor_y{};  
        };
    };
 
    inline Mode mode() const
    {
        return data_mode;
    }
    Gesture gesture() const
    {
        return data_gesture;
    }
 
    inline uint8_t brightness() const
    {
        return (data_mode == Mode::Proximity) ? proximity_brightness : 0;
    }
    inline bool approach() const
    {
        return (data_mode == Mode::Proximity) ? proximity_approach : false;
    }
 
    inline uint16_t cursorX() const
    {
        return (data_mode == Mode::Cursor) ? cursor_x : 0xFFFF;
    }
    inline uint16_t cursorY() const
    {
        return (data_mode == Mode::Cursor) ? cursor_y : 0xFFFF;
    }
};
 
}  // namespace paj7620u2
 
class UnitPAJ7620U2 : public Component, public PeriodicMeasurementAdapter<UnitPAJ7620U2, paj7620u2::Data> {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitPAJ7620U2, 0x73);
 
public:
    struct config_t {
        bool start_periodic{true};
        paj7620u2::Mode mode{paj7620u2::Mode::Gesture};
        paj7620u2::Frequency frequency{paj7620u2::Frequency::Normal};
        bool hflip{false};
        bool vflip{true};
        uint8_t rotation{0};
        bool store_on_change{true};
    };
 
    explicit UnitPAJ7620U2(const uint8_t addr = DEFAULT_ADDRESS)
        : Component(addr), _data{new m5::container::CircularBuffer<paj7620u2::Data>(1)}
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitPAJ7620U2()
    {
    }
 
    virtual bool begin() override;
    virtual void update(const bool force = false) override;
 
 
    inline config_t config() const
    {
        return _cfg;
    }
    inline void config(const config_t& cfg)
    {
        _cfg = cfg;
    }
 
 
    inline paj7620u2::Gesture gesture() const
    {
        return !empty() ? oldest().gesture() : paj7620u2::Gesture::None;
    }
    inline uint8_t brightness() const
    {
        return !empty() ? oldest().brightness() : 0;
    }
    inline bool approach() const
    {
        return !empty() ? oldest().approach() : false;
    }
    uint16_t cursorX() const
    {
        return !empty() ? oldest().cursorX() : 0xFFFF;
    }
    uint16_t cursorY() const
    {
        return !empty() ? oldest().cursorY() : 0xFFFF;
    }
 
 
    bool startPeriodicMeasurement(const uint32_t intervalMs = 0)
    {
        return PeriodicMeasurementAdapter<UnitPAJ7620U2, paj7620u2::Data>::startPeriodicMeasurement(intervalMs);
    }
    bool startPeriodicMeasurement(const paj7620u2::Mode mode, const paj7620u2::Frequency freq,
                                  const uint32_t intervalMs)
    {
        return PeriodicMeasurementAdapter<UnitPAJ7620U2, paj7620u2::Data>::startPeriodicMeasurement(mode, freq,
                                                                                                    intervalMs);
    }
    bool stopPeriodicMeasurement()
    {
        return PeriodicMeasurementAdapter<UnitPAJ7620U2, paj7620u2::Data>::stopPeriodicMeasurement();
    }
 
    inline uint8_t rotation() const
    {
        return _rotation;
    }
    void setRotate(const uint8_t rot)
    {
        _rotation = rot & 0x03;
    }
 
    paj7620u2::Frequency frequency() const
    {
        return _frequency;
    }
    bool readFrequency(uint16_t& raw);
    [[deprecated("Use readFrequency(uint16_t&) instead")]] bool readFrequency(uint8_t& raw)
    {
        uint16_t v{};
        raw = 0;
        if (readFrequency(v)) {
            raw = static_cast<uint8_t>(v & 0xFF);
            return true;
        }
        return false;
    }
    bool readFrequency(paj7620u2::Frequency& f);
    bool writeFrequency(const paj7620u2::Frequency f);
    float readFrequencyHz();
    bool writeFrequencyHz(const float hz);
 
 
    bool readGesture(paj7620u2::Gesture& gesture);
    bool readObjectCenter(uint16_t& x, uint16_t& y);
    bool readObjectSize(uint16_t& sz);
    bool existsObject(bool& exists)
    {
        uint8_t e{};
        if (readNoObjectCount(e)) {
            exists = (e == 0);
            return true;
        }
        return false;
    }
    bool readNoObjectCount(uint8_t& cnt);
    bool readNoMotionCount(uint8_t& cnt);
 
 
    bool readProximity(uint8_t& brightness, uint8_t& approach);
 
    bool readApproachThreshold(uint8_t& high, uint8_t& low);
    bool writeApproachThreshold(const uint8_t high, const uint8_t low);
 
 
    bool readCursor(uint16_t& x, uint16_t& y);
 
 
    inline paj7620u2::Mode mode() const
    {
        return _mode;
    }
    bool writeMode(const paj7620u2::Mode mode);
 
    bool readHorizontalFlip(bool& flip);
    bool readVerticalFlip(bool& flip);
    bool writeHorizontalFlip(const bool flip);
    bool writeVerticalFlip(const bool flip);
 
 
    bool enable(const bool flag);
    inline bool enable()
    {
        return enable(true);
    }
    inline bool disable()
    {
        return enable(false);
    }
    bool suspend();
    bool resume();
 
protected:
    bool start_periodic_measurement(const uint32_t intervalMs = 0);
    bool start_periodic_measurement(const paj7620u2::Mode mode, const paj7620u2::Frequency freq,
                                    const uint32_t intervalMs);
    bool stop_periodic_measurement();
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitPAJ7620U2, paj7620u2::Data);
 
    bool select_bank(const uint8_t bank, const bool force = false);
 
    bool read_banked_register(const uint16_t reg, uint8_t* buf, const size_t len);
    bool read_banked_register8(const uint16_t reg, uint8_t& value);
    bool write_banked_register(const uint16_t reg, const uint8_t* buf, const size_t len);
    bool write_banked_register8(const uint16_t reg, const uint8_t value);
 
    bool update_gesture(paj7620u2::Data& d);
    bool update_proximity(paj7620u2::Data& d);
    bool update_cursor(paj7620u2::Data& d);
 
    bool read_gesture(paj7620u2::Data& d);
    bool read_proximity(paj7620u2::Data& d);
    bool read_cursor(paj7620u2::Data& d);
 
    bool apply_flip();
 
    bool wakeup();
    bool was_wakeup();
    bool read_chip_id(uint16_t& id);
    bool read_version(uint8_t& version);
 
protected:
    uint8_t _current_bank{0xFF};
    paj7620u2::Mode _mode{};
    paj7620u2::Frequency _frequency{};
    uint8_t _rotation{};
    bool _hflip{}, _vflip{true};
 
    std::unique_ptr<m5::container::CircularBuffer<paj7620u2::Data>> _data{};
    config_t _cfg{};
};
 
namespace paj7620u2 {
namespace command {
 
// Bank 0/1
constexpr uint8_t BANK_SEL{0xEF};
// high byte:bank low byte: register
// Bank 0
constexpr uint16_t PART_ID_LOW{0x0000};
constexpr uint16_t PART_ID_HIGH{0x0001};
constexpr uint16_t VERSION_ID{0x0002};
constexpr uint16_t SW_SUSPEND_ENL{0x0003};
 
constexpr uint16_t CURSOR_CLAMP_CENTER_X_LOW{0x003B};
constexpr uint16_t CURSOR_CLAMP_CENTER_X_HIGH{0x003C};
constexpr uint16_t CURSOR_CLAMP_CENTER_Y_LOW{0x003D};
constexpr uint16_t CURSOR_CLAMP_CENTER_Y_HIGH{0x003E};
 
constexpr uint16_t INT_FLAG_1{0x0043};
constexpr uint16_t INT_FLAG_2{0x0044};
 
constexpr uint16_t R_POX_UB{0x0069};
constexpr uint16_t R_POX_LB{0x006A};
constexpr uint16_t S_STATE{0x006B};
constexpr uint16_t S_AVGY{0x006C};
 
constexpr uint16_t OBJECT_CENTER_X_LOW{0x00AC};
constexpr uint16_t OBJECT_CENTER_X_HIGH{0x00AD};
constexpr uint16_t OBJECT_CENTER_Y_LOW{0x00AE};
constexpr uint16_t OBJECT_CENTER_Y_HIGH{0x00AF};
 
constexpr uint16_t OBJECT_AVG_Y{0x00B0};
constexpr uint16_t OBJECT_SIZE_LOW{0x00B1};
constexpr uint16_t OBJECT_SIZE_HIGH{0x00B2};
constexpr uint16_t WAVE_ABORT_COUNT{0x00B7};
constexpr uint16_t NO_OBJECT_COUNT{0x00B8};
constexpr uint16_t NO_MOTION_COUNT{0x00B9};
 
constexpr uint16_t VEL_X_LOW{0x00C3};
constexpr uint16_t VEL_X_HIGH{0x00C4};
constexpr uint16_t VEL_Y_LOW{0x00C5};
constexpr uint16_t VEL_Y_HIGH{0x00C6};
 
// Bank1
constexpr uint16_t LS_COMP_DAVG_V{0x0104};
constexpr uint16_t R_IDLE_TIME_LOW{0x0165};
constexpr uint16_t R_IDLE_TIME_HIGH{0x0166};
constexpr uint16_t R_TG_ENH{0x0172};
}  // namespace command
}  // namespace paj7620u2
 
}  // namespace unit
}  // namespace m5
 
#endif