HapticDriver_AW86224.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_HAPTIC_AW86224
 
#include "platform/comm/I2CDeviceWithHal.hpp"
#include "HapticBase.hpp"
 
static constexpr uint8_t AW8624_SLAVE_ADDRESS = (0x58);
 
class HapticDriver_AW86224 : public HapticBase, public I2CDeviceWithHal
{
public:
 
    enum class PlayMode : uint8_t {
        STANDBY = 0,  
        RAM = 1,      
        RAM_LOOP = 2, 
        CONT = 3,     
        RTP = 4       
    };
 
    enum class SramSize : uint8_t {
        SRAM_1K = 0,  
        SRAM_2K = 1,  
        SRAM_3K = 2   
    };
 
    enum class ChipID : uint8_t {
        AW86223 = 1,  
        AW86224 = 2,  
        AW86225 = 3,  
        AW86214 = 4   
    };
 
    enum class PwmMode : uint8_t {
        PWM_48K = 0,  
        PWM_24K = 1,  
        PWM_12K = 2   
    };
 
    //=========================================================================
    // Constructor & Initialization
    //=========================================================================
 
    HapticDriver_AW86224();
 
    //=========================================================================
    // HapticBase Interface - Lifecycle
    //=========================================================================
 
    void setPins(uint8_t resetPin, uint8_t intPin);
 
    void end() override;
    bool isReady() const override;
    const char *getChipName() const override;
 
    //=========================================================================
    // HapticBase Interface - Playback Control
    //=========================================================================
 
    bool run() override;
    bool stop() override;
    bool isPlaying() const override;
    HapticStatus getStatus() const override;
 
    //=========================================================================
    // HapticBase Interface - Gain Control
    //=========================================================================
 
    bool setGain(uint8_t gain) override;
    uint8_t getGain() const override;
 
    //=========================================================================
    // HapticBase Interface - Effect Playback
    //=========================================================================
 
    bool playEffect(HapticEffectId effect) override;
    bool playEffectAsync(HapticEffectId effect) override;
    void continuousVibration(uint32_t duration_ms, bool blocking = true) override;
    void vibrationUpdate() override;
 
    //=========================================================================
    // HapticBase Interface - Waveform Sequence
    //=========================================================================
 
    bool setSequence(uint8_t slot, HapticEffectId effect) override;
    bool clearSequence() override;
    bool playSequence() override;
 
    //=========================================================================
    // HapticBase Interface - Device Information
    //=========================================================================
 
    uint8_t getChipID() const override;
    HapticCapabilities getCapabilities() const override;
 
    //=========================================================================
    // HapticBase Interface - Calibration
    //=========================================================================
 
    bool calibrate() override;
    bool needsCalibration() const override;
    uint32_t getF0() const override;
    uint32_t getVbat() override;
 
    //=========================================================================
    // HapticBase Interface - Mode Control
    //=========================================================================
 
    bool setMode(HapticMode mode) override;
    HapticMode getMode() const override;
    HapticActuatorType getActuatorType() const override;
    bool setActuatorType(HapticActuatorType type) override;
 
    //=========================================================================
    // HapticBase Interface - RTP
    //=========================================================================
 
    bool setRealtimeValue(uint8_t value) override;
 
    //=========================================================================
    // Core Playback Control
    //=========================================================================
 
    void softReset();
 
    //=========================================================================
    // Vibration Effects
    //=========================================================================
 
    void shortVibration(uint8_t index, uint8_t gain = 0x80, uint8_t loop = 1);
 
    void longVibration(uint8_t index, uint8_t gain = 0x80, uint32_t duration_ms = 1000, bool blocking = true);
 
    void stopVibration();
 
    //=========================================================================
    // Waveform Configuration
    //=========================================================================
 
    void setWaveSeq(uint8_t wav, uint8_t seq);
 
    void setWaveLoop(uint8_t wav, uint8_t loop);
 
    void setPlayMode(PlayMode mode);
 
    void setTrimLRA(uint8_t val);
 
    //=========================================================================
    // RTP (Real-Time Playback) Mode
    //=========================================================================
 
    void setRtpData(uint8_t *data, uint32_t len);
 
    bool playRtp(const uint8_t *data, uint32_t len, uint8_t gain = 0x80);
 
    //=========================================================================
    // Calibration Functions
    //=========================================================================
 
    bool loadRamData(const uint8_t *data, uint32_t len);
 
    //=========================================================================
    // Status & Information Getters
    //=========================================================================
 
    uint8_t getRamNum() const
    {
        return _ramNum;
    }
 
    bool isRamInit() const
    {
        return _ramInit;
    }
 
    uint32_t getVbatValue() const
    {
        return _vbat;
    }
 
    PlayMode getPlayMode() const
    {
        return _playMode;
    }
 
    int8_t getF0CaliData() const
    {
        return _f0_cali_data;
    }
 
    uint32_t getLraValue() const
    {
        return _lra;
    }
 
    //=========================================================================
    // Parameter Setters (for advanced configuration)
    //=========================================================================
 
    void setF0Pre(uint32_t val)
    {
        _f0_pre = val;
    }
    uint32_t getF0Pre() const
    {
        return _f0_pre;
    }
 
    void setLraVrms(uint32_t val)
    {
        _lra_vrms = val;
    }
    uint32_t getLraVrms() const
    {
        return _lra_vrms;
    }
 
    void setContBrkTime(uint8_t val)
    {
        _cont_brk_time = val;
    }
    uint8_t getContBrkTime() const
    {
        return _cont_brk_time;
    }
 
    void setContBrkGain(uint8_t val)
    {
        _cont_brk_gain = val;
    }
    uint8_t getContBrkGain() const
    {
        return _cont_brk_gain;
    }
 
    void setContDrv1Lvl(uint8_t val)
    {
        _cont_drv1_lvl = val;
    }
    uint8_t getContDrv1Lvl() const
    {
        return _cont_drv1_lvl;
    }
 
    void setContDrv1Time(uint8_t val)
    {
        _cont_drv1_time = val;
    }
    uint8_t getContDrv1Time() const
    {
        return _cont_drv1_time;
    }
 
    void setContDrv2Time(uint8_t val)
    {
        _cont_drv2_time = val;
    }
    uint8_t getContDrv2Time() const
    {
        return _cont_drv2_time;
    }
 
    void setContTrackMargin(uint8_t val)
    {
        _cont_track_margin = val;
    }
    uint8_t getContTrackMargin() const
    {
        return _cont_track_margin;
    }
 
    void setD2sGain(uint8_t val)
    {
        _d2s_gain = val;
    }
    uint8_t getD2sGain() const
    {
        return _d2s_gain;
    }
 
    void setPwmcfg4Prtime(uint8_t val)
    {
        _pwmcfg4_prtime = val;
    }
    uint8_t getPwmcfg4Prtime() const
    {
        return _pwmcfg4_prtime;
    }
 
    void setPwmcfg3Prlvl(uint8_t val)
    {
        _pwmcfg3_prlvl = val;
    }
    uint8_t getPwmcfg3Prlvl() const
    {
        return _pwmcfg3_prlvl;
    }
 
    void setAutoBrkEnabled(bool val)
    {
        _auto_brk_enabled = val;
    }
    bool getAutoBrkEnabled() const
    {
        return _auto_brk_enabled;
    }
 
    void setF0CaliPercent(uint8_t val)
    {
        _f0_cali_percent = val;
    }
    uint8_t getF0CaliPercent() const
    {
        return _f0_cali_percent;
    }
 
    bool isVibrating() const
    {
        return isPlaying();
    }
 
private:
    // Internal helper functions
    bool waitRtpGo(uint32_t timeout_ms);
 
    void printRegs();
 
    // RAM initialization
    void ramInit(bool enable);
    void playStop();
    void reset();
    bool checkQualify();
    bool offsetCalibration();
    int selectD2sGain(uint8_t reg);
    bool measureF0();
    bool measureVbat();
    void getLraResistance();
    void setSramSize(SramSize size);
    void setFifoAddr();
    void setBaseAddr();
    void setRamAddr();
    bool getBaseAddr(const uint8_t *data, uint32_t len);
    void setRepeatSeq(uint8_t seq);
    void autoBrkConfig(bool enable);
    void setPwm(PwmMode mode);
    void playMode(PlayMode mode);
    void config();
    void protectConfig(uint8_t prtime, uint8_t prlvl);
    void miscParaInit();
    void trigInit();
    void contConfig();
    void interruptSetup();
    void vbatModeConfig(uint8_t flag);
    void calculateCaliData();
    bool parseChipID();
    void hapticInit();
    void f0Calibration();
    bool judgeF0WithinRange();
    uint8_t getGlobalState() const;
    bool waitStandby(uint32_t timeout_ms = 100);
    int getIrqState();
    void irqClear();
    uint8_t rtpGetFifoAfs();
    void setRtpAei(bool enable);
    void cancelVibration();
    void ram_vbat_comp(bool flag);
 
    // Calculation formulas
    inline uint8_t drv2_lvl_formula(uint32_t f0, uint32_t vrms)
    {
        uint32_t base = (f0 < 1800) ? 1809920 : 1990912;
        return static_cast<uint8_t>((base / 1000 * vrms) / 61000);
    }
 
    bool initImpl(uint8_t param);
 
    void afterInitSuccess(uint8_t param) override
    {
        setReady(true);
    }
 
    inline uint32_t vbat_formula(uint32_t value)
    {
        return (6100 * (value) / 1024);
    }
 
    inline uint32_t f0_formula(uint32_t value)
    {
        return (384000 * 10 / (value));
    }
 
    inline uint32_t rl_formula(uint32_t value, uint32_t gain)
    {
        return (((value) * 678 * 100) / (1024 * (gain)));
    }
 
    inline int os_formula(int value, int d2s_gain)
    {
        return (2440 * (value - 512) / (1024 * (d2s_gain + 1)));
    }
 
    // Member variables
    int _rstPin;
    int _intPin;
    uint8_t _chipID;
    PlayMode _playMode;
    uint8_t _gain;
    uint32_t _f0;
    uint32_t _vbat;
    uint32_t _lra;
    bool _ramInit;
    uint8_t _cont_drv2_lvl;
    int8_t _f0_cali_data;
    uint32_t _f0_pre;
    uint16_t _ramBaseAddr;
    uint8_t _ramNum;
    uint32_t _lra_vrms;
    uint8_t _cont_brk_time;
    uint8_t _cont_brk_gain;
    uint8_t _cont_drv1_lvl;
    uint8_t _cont_drv1_time;
    uint8_t _cont_drv2_time;
    uint8_t _cont_track_margin;
    uint8_t _d2s_gain;
    uint8_t _pwmcfg4_prtime;
    uint8_t _pwmcfg3_prlvl;
    bool _auto_brk_enabled;
    uint8_t _f0_cali_percent;
    uint32_t _duration;
    uint32_t _vibrationStartTime;
    bool _isCalibrated;
};
 
#endif