sensor/light_sensor/SensorCM32181.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_CM32181
 
#include "../../platform/comm/I2CDeviceNoHal.hpp"
 
static constexpr uint8_t CM32181_ADDR_PRIMARY = 0x10;
 
static constexpr uint8_t CM32181_ADDR_SECONDARY = 0x48;
 
static constexpr uint8_t CM32181_SLAVE_ADDRESS = 0x10;
 
class SensorCM32181 : public I2CDeviceNoHal
{
public:
    enum Sampling : uint8_t {
        SAMPLING_X1 = 0,    
        SAMPLING_X2 = 1,    
        SAMPLING_X1_8 = 2,  
        SAMPLING_X1_4 = 3,  
    };
 
    enum IntegrationTime : uint8_t {
        INTEGRATION_TIME_25MS  = 0x0C, 
        INTEGRATION_TIME_50MS  = 0x08, 
        INTEGRATION_TIME_100MS = 0x00, 
        INTEGRATION_TIME_200MS = 0x01, 
        INTEGRATION_TIME_400MS = 0x02, 
        INTEGRATION_TIME_800MS = 0x03, 
    };
 
    enum PowerSaveMode : uint8_t {
        PowerSaveMode1 = 0,
        PowerSaveMode2 = 1,
        PowerSaveMode3 = 2,
        PowerSaveMode4 = 3
    };
 
    enum InterruptEvent : uint8_t {
        ALS_EVENT_LOW_TRIGGER = 0, 
        ALS_EVENT_HIGH_TRIGGER,    
        ALS_EVENT_NULL,            
    };
 
    SensorCM32181() = default;
 
    ~SensorCM32181() = default;
 
    void setSampling(Sampling sampling = SAMPLING_X1,
                     IntegrationTime int_time = INTEGRATION_TIME_200MS)
    {
        uint16_t data = 0;
        readRegBuff(REG_ALS_CONF, (uint8_t *)&data, 2);
 
        // Sensitivity bits [12:11]
        data &= (uint16_t)~ALS_CONF_SENS_MASK;
        data |= (uint16_t)(sampling & 0x03u) << ALS_CONF_SENS_SHIFT;
 
        // Integration time bits [9:6]
        data &= (uint16_t)~ALS_CONF_IT_MASK;
        data |= (uint16_t)(int_time & 0x0Fu) << ALS_CONF_IT_SHIFT;
 
        // FIX: Write back configuration (original code mistakenly read instead of write)
        writeRegBuff(REG_ALS_CONF, (uint8_t *)&data, 2);
    }
 
    void setIntThreshold(uint16_t low_threshold, uint16_t high_threshold)
    {
        uint8_t buffer[2] = {0};
 
        // High threshold window (REG_ALS_THDH)
        buffer[1] = sensorlib::_highByte(high_threshold);
        buffer[0] = sensorlib::_lowByte(high_threshold);
        writeRegBuff(REG_ALS_THDH, buffer, 2);
 
        // Low threshold window (REG_ALS_THDL)
        buffer[1] = sensorlib::_highByte(low_threshold);
        buffer[0] = sensorlib::_lowByte(low_threshold);
        writeRegBuff(REG_ALS_THDL, buffer, 2);
    }
 
    void powerSave(PowerSaveMode mode, bool enable)
    {
        uint16_t data = 0;
        readRegBuff(REG_ALS_PSM, (uint8_t *)&data, 2);
 
        // Clear mode bits [2:1] and enable bit [0]
        data &= (uint16_t)~ALS_PSM_MODE_MASK;
        data &= (uint16_t)~ALS_PSM_EN_BIT;
 
        // Set mode
        data |= (uint16_t)(mode & 0x03u) << ALS_PSM_MODE_SHIFT;
 
        // Set enable
        if (enable) {
            data |= ALS_PSM_EN_BIT;
        }
 
        writeRegBuff(REG_ALS_PSM, (uint8_t *)&data, 2);
    }
 
    InterruptEvent getIrqStatus()
    {
        uint16_t data = 0;
        readRegBuff(REG_ALS_STATUS, (uint8_t *)&data, 2);
 
        // Keep original mapping:
        // bit15 => low threshold trigger
        // bit14 => high threshold trigger
        if (sensorlib::_bitRead(data, 15)) {
            return ALS_EVENT_LOW_TRIGGER;
        }
        if (sensorlib::_bitRead(data, 14)) {
            return ALS_EVENT_HIGH_TRIGGER;
        }
        return ALS_EVENT_NULL;
    }
 
    void enableINT()
    {
        uint16_t data = 0;
        readRegBuff(REG_ALS_CONF, (uint8_t *)&data, 2);
        sensorlib::_bitWrite(data, 1, 1);
        writeRegBuff(REG_ALS_CONF, (uint8_t *)&data, 2);
    }
 
    void disableINT()
    {
        uint16_t data = 0;
        readRegBuff(REG_ALS_CONF, (uint8_t *)&data, 2);
        sensorlib::_bitWrite(data, 1, 0);
        writeRegBuff(REG_ALS_CONF, (uint8_t *)&data, 2);
    }
 
    void powerOn()
    {
        uint16_t data = 0;
        readRegBuff(REG_ALS_CONF, (uint8_t *)&data, 2);
        sensorlib::_bitClear(data, 0);
        writeRegBuff(REG_ALS_CONF, (uint8_t *)&data, 2);
    }
 
    void powerDown()
    {
        uint16_t data = 0;
        readRegBuff(REG_ALS_CONF, (uint8_t *)&data, 2);
        sensorlib::_bitSet(data, 0);
        writeRegBuff(REG_ALS_CONF, (uint8_t *)&data, 2);
    }
 
    uint16_t getRaw()
    {
        uint8_t buffer[2] = {0};
        readRegBuff(REG_ALS_DATA, buffer, 2);
        return (uint16_t)buffer[0] | (uint16_t)(buffer[1] << 8);
    }
 
    float getLux()
    {
        return getRaw() * calibration_factor;
    }
 
    int getChipID()
    {
        uint8_t buffer[2] = {0};
        readRegBuff(REG_ID, buffer, 2);
        return sensorlib::_lowByte(buffer[0]);
    }
 
private:
    // ---- Register addresses (datasheet command codes) ----
    static constexpr uint8_t REG_ALS_CONF   = 0x00;
    static constexpr uint8_t REG_ALS_THDH   = 0x01;
    static constexpr uint8_t REG_ALS_THDL   = 0x02;
    static constexpr uint8_t REG_ALS_PSM    = 0x03;
    static constexpr uint8_t REG_ALS_DATA   = 0x04;
    static constexpr uint8_t REG_ALS_STATUS = 0x06;
    static constexpr uint8_t REG_ID         = 0x07;
 
    // ---- Chip ID ----
    static constexpr uint8_t CM32181_CHIP_ID = 0x81;
 
    // ---- Bit field masks/shifts (from datasheet screenshot) ----
    // REG_ALS_CONF (0x00): bits 12:11 sensitivity, bits 9:6 integration time
    static constexpr uint16_t ALS_CONF_SENS_SHIFT = 11;
    static constexpr uint16_t ALS_CONF_SENS_MASK  = (uint16_t)(0x03u << ALS_CONF_SENS_SHIFT);
 
    static constexpr uint16_t ALS_CONF_IT_SHIFT   = 6;
    static constexpr uint16_t ALS_CONF_IT_MASK    = (uint16_t)(0x0Fu << ALS_CONF_IT_SHIFT);
 
    // REG_ALS_PSM (0x03): bits 2:1 mode, bit0 enable
    static constexpr uint16_t ALS_PSM_EN_BIT      = (uint16_t)(1u << 0);
    static constexpr uint16_t ALS_PSM_MODE_SHIFT  = 1;
    static constexpr uint16_t ALS_PSM_MODE_MASK   = (uint16_t)(0x03u << ALS_PSM_MODE_SHIFT);
 
    bool initImpl(uint8_t param) override
    {
        setAck(false);
 
        int chipID = getChipID();
        SENSORLIB_LOG_I("chipID:%d", chipID);
 
        if (chipID < 0) {
            return false;
        }
        if (chipID != CM32181_CHIP_ID) {
            return false;
        }
        return true;
    }
 
protected:
    const float calibration_factor = 0.286f;
};
 
#endif