sensor/light_sensor/SensorLTR553.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_LTR553
 
#include "../../platform/comm/I2CDeviceNoHal.hpp"
 
// Unique I2C device address
static constexpr uint8_t LTR553_SLAVE_ADDRESS = 0x23;
 
class SensorLTR553 : public I2CDeviceNoHal
{
public:
    enum IrqLevel {
        ALS_IRQ_ACTIVE_LOW,  
        ALS_IRQ_ACTIVE_HIGH  
    };
 
    enum IrqMode {
        ALS_IRQ_DISABLE = 0,   
        ALS_IRQ_ONLY_PS = 1,   
        ALS_IRQ_ONLY_ALS = 2,  
        ALS_IRQ_BOTH = 3,      
    };
 
    enum LightSensorGain {
        ALS_GAIN_1X  = 0x00,  
        ALS_GAIN_2X  = 0x01,  
        ALS_GAIN_4X  = 0x02,  
        ALS_GAIN_8X  = 0x03,  
        ALS_GAIN_48X = 0x06,  
        ALS_GAIN_96X = 0x07,  
    };
 
    enum PsLedPeriod {
        PS_LED_PLUSE_30KHZ,   
        PS_LED_PLUSE_40KHZ,   
        PS_LED_PLUSE_50KHZ,   
        PS_LED_PLUSE_60KHZ,   
        PS_LED_PLUSE_70KHZ,   
        PS_LED_PLUSE_80KHZ,   
        PS_LED_PLUSE_90KHZ,   
        PS_LED_PLUSE_100KHZ,  
    };
 
    enum PsLedDuty {
        PS_LED_DUTY_25,   
        PS_LED_DUTY_50,   
        PS_LED_DUTY_75,   
        PS_LED_DUTY_100,  
    };
 
    enum PsLedCurrent {
        PS_LED_CUR_5MA,    
        PS_LED_CUR_10MA,   
        PS_LED_CUR_20MA,   
        PS_LED_CUR_50MA,   
        PS_LED_CUR_100MA,  
    };
 
    enum PsRate {
        PS_MEAS_RATE_50MS,
        PS_MEAS_RATE_70MS,
        PS_MEAS_RATE_100MS,
        PS_MEAS_RATE_200MS,
        PS_MEAS_RATE_500MS,
        PS_MEAS_RATE_1000MS,
        PS_MEAS_RATE_2000MS,
        PS_MEAS_RATE_10MS = 8,
    };
 
    enum IntegrationTime {
        ALS_INTEGRATION_TIME_100MS,
        ALS_INTEGRATION_TIME_50MS,
        ALS_INTEGRATION_TIME_200MS,
        ALS_INTEGRATION_TIME_400MS,
        ALS_INTEGRATION_TIME_150MS,
        ALS_INTEGRATION_TIME_250MS,
        ALS_INTEGRATION_TIME_300MS,
        ALS_INTEGRATION_TIME_350MS,
    };
 
    enum MeasurementRate {
        ALS_MEASUREMENT_TIME_50MS,
        ALS_MEASUREMENT_TIME_100MS,
        ALS_MEASUREMENT_TIME_200MS,
        ALS_MEASUREMENT_TIME_500MS,
        ALS_MEASUREMENT_TIME_1000MS,
        ALS_MEASUREMENT_TIME_2000MS,
    };
 
    SensorLTR553() = default;
 
    ~SensorLTR553() = default;
 
    void setIRQLevel(IrqLevel  level)
    {
        if (level) {
            setRegBit(REG_INTERRUPT, 2);
        } else {
            clrRegBit(REG_INTERRUPT, 2);
        }
    }
 
    void enableIRQ(IrqMode mode)
    {
        // RESERVED:7:3
        // Interrupt Polarity : 2
        // Interrupt Mode : 1:0
        updateBits(REG_INTERRUPT, 0x03, mode);
    }
 
    void disableIRQ()
    {
        updateBits(REG_INTERRUPT, 0x03, 0x00);
    }
 
    // -----------------------
    // ALS (Ambient Light)
    // -----------------------
 
    bool psAvailable()
    {
        return getRegBit(REG_ALS_PS_STATUS, 0);
    }
 
    void setLightSensorThreshold(uint16_t low, uint16_t high)
    {
        uint8_t buffer[4] = {
            sensorlib::_lowByte(high), sensorlib::_highByte(high),
            sensorlib::_lowByte(low),  sensorlib::_highByte(low)
        };
        writeRegBuff(REG_ALS_THRES_UP_0, buffer, 4);
    }
 
    void setLightSensorPersists(uint8_t count)
    {
        updateBits(REG_INTERRUPT_PERSIST, 0x0F, count - 1);
    }
 
    void setLightSensorRate(IntegrationTime alsIntegrationTime, MeasurementRate alsMeasurementRate)
    {
        uint8_t value = (uint8_t)(((alsIntegrationTime & 0x07) << 3) | (alsMeasurementRate & 0x07));
        writeReg(REG_ALS_MEAS_RATE, value);
    }
 
    void enableLightSensor()
    {
        setRegBit(REG_ALS_CONTR, 0);
    }
 
    void disableLightSensor()
    {
        clrRegBit(REG_ALS_CONTR, 0);
    }
 
    void setLightSensorGain(LightSensorGain gain)
    {
        updateBits(REG_ALS_CONTR, 0x1C, gain << 2);
    }
 
    int getLightSensor(uint8_t ch)
    {
        uint8_t buffer[2] = {0};
 
        // Check ALS Data is Valid (datasheet bit definition should be checked if needed)
        if (getRegBit(REG_ALS_PS_STATUS, 7) != false) {
            return -1;
        }
 
        int val = readRegBuff(ch == 1 ? REG_ALS_DATA_CH1_0 : REG_ALS_DATA_CH0_0, buffer, 2);
        if (val == -1) {
            return -1;
        }
 
        return (int)buffer[0] | ((int)buffer[1] << 8);
    }
 
    // -----------------------
    // PS (Proximity)
    // -----------------------
 
    void setProximityPersists(uint8_t count)
    {
        uint8_t val = (count == 0) ? 0 : (count - 1);
        if (val > 0x0F) {
            val = 0x0F;
        }
        updateBits(REG_INTERRUPT_PERSIST, 0xF0, val << 4);
    }
 
    void setProximityThreshold(uint16_t low, uint16_t high)
    {
        writeReg(REG_PS_THRES_UP_0, sensorlib::_lowByte(high));
        writeReg(REG_PS_THRES_UP_1, sensorlib::_lowByte(high >> 8) & 0x0F);
        writeReg(REG_PS_THRES_LOW_0, sensorlib::_lowByte(low));
        writeReg(REG_PS_THRES_LOW_1, sensorlib::_lowByte(low >> 8) & 0x0F);
    }
 
    void setProximityRate(PsRate rate)
    {
        updateBits(REG_PS_MEAS_RATE, 0x0F, rate & 0x0F);
    }
 
    void enableProximity()
    {
        updateBits(REG_PS_CONTR, 0x03, 0x03);
    }
 
    void disableProximity()
    {
        updateBits(REG_PS_CONTR, 0x03, 0x00);
    }
 
    void enablePsIndicator()
    {
        setRegBit(REG_PS_CONTR, 5);
    }
 
    void disablePsIndicator()
    {
        clrRegBit(REG_PS_CONTR, 5);
    }
 
    int getProximity(bool *saturated = NULL )
    {
        uint8_t buffer[2] = {0};
        int val = readRegBuff(REG_PS_DATA_0, buffer, 2);
        if (val == -1) {
            return -1;
        }
        if (saturated) {
            *saturated = (buffer[1] & 0x80) == 0x80;
        }
        return (int)buffer[0] | ((int)(buffer[1] & 0x07) << 8);
    }
 
    // -----------------------
    // PS LED configuration
    // -----------------------
 
    void setPsLedPulsePeriod(PsLedPeriod period)
    {
        updateBits(REG_PS_LED, 0xE0, static_cast<uint8_t>(period) << 5);
    }
 
    void setPsLedDutyCycle(PsLedDuty duty)
    {
        updateBits(REG_PS_LED, 0x18, static_cast<uint8_t>(duty) << 3);
    }
 
    void setPsLedCurrent(PsLedCurrent cur)
    {
        updateBits(REG_PS_LED, 0x07, static_cast<uint8_t>(cur));
    }
 
    void setPsLedPulses(uint8_t pulesNum)
    {
        updateBits(REG_PS_N_PULSES, 0x0F, pulesNum & 0x0F);
    }
 
    // -----------------------
    // Identification / reset
    // -----------------------
 
    int getPartID()
    {
        int val = readReg(REG_PART_ID);
        if (val == -1) {
            return -1;
        }
        return (val >> 4) & 0x0F;
    }
 
    int getRevisionID()
    {
        int val = readReg(REG_PART_ID);
        if (val == -1) {
            return -1;
        }
        return (val) & 0x0F;
    }
 
    int getManufacturerID()
    {
        // Manufacturer ID (0x05H)
        return readReg(REG_MANUFAC_ID);
    }
 
    void reset()
    {
        setRegBit(REG_ALS_CONTR, 1);
    }
 
private:
    bool initImpl(uint8_t param)
    {
        setAck(false);
        reset();
        return getManufacturerID() == LTR553_DEFAULT_MAN_ID;
    }
 
protected:
    // Register map
    static constexpr uint8_t REG_ALS_CONTR = 0x80;
    static constexpr uint8_t REG_PS_CONTR = 0x81;
    static constexpr uint8_t REG_PS_LED = 0x82;
    static constexpr uint8_t REG_PS_N_PULSES = 0x83;
    static constexpr uint8_t REG_PS_MEAS_RATE = 0x84;
    static constexpr uint8_t REG_ALS_MEAS_RATE = 0x85;
    static constexpr uint8_t REG_PART_ID = 0x86;
    static constexpr uint8_t REG_MANUFAC_ID = 0x87;
    static constexpr uint8_t REG_ALS_DATA_CH1_0 = 0x88;
    static constexpr uint8_t REG_ALS_DATA_CH1_1 = 0x89;
    static constexpr uint8_t REG_ALS_DATA_CH0_0 = 0x8A;
    static constexpr uint8_t REG_ALS_DATA_CH0_1 = 0x8B;
    static constexpr uint8_t REG_ALS_PS_STATUS = 0x8C;
    static constexpr uint8_t REG_PS_DATA_0 = 0x8D;
    static constexpr uint8_t REG_PS_DATA_1 = 0x8E;
    static constexpr uint8_t REG_INTERRUPT = 0x8F;
    static constexpr uint8_t REG_PS_THRES_UP_0 = 0x90;
    static constexpr uint8_t REG_PS_THRES_UP_1 = 0x91;
    static constexpr uint8_t REG_PS_THRES_LOW_0 = 0x92;
    static constexpr uint8_t REG_PS_THRES_LOW_1 = 0x93;
    static constexpr uint8_t REG_PS_OFFSET_1 = 0x94;
    static constexpr uint8_t REG_PS_OFFSET_0 = 0x95;
    static constexpr uint8_t REG_ALS_THRES_UP_0 = 0x97;
    static constexpr uint8_t REG_ALS_THRES_UP_1 = 0x98;
    static constexpr uint8_t REG_ALS_THRES_LOW_0 = 0x99;
    static constexpr uint8_t REG_ALS_THRES_LOW_1 = 0x9A;
    static constexpr uint8_t REG_INTERRUPT_PERSIST = 0x9E;
 
    static constexpr uint8_t LTR553_DEFAULT_MAN_ID = 0x05;
};
 
#endif