sfDevVEML7700.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
 
// include the sparkfun toolkit headers
#include <sfTk/sfToolkit.h>
 
// Bus interfaces
#include <sfTk/sfTkII2C.h>
 
typedef uint16_t VEML7700_t;
 
#define SF_VEML7700_DEFAULT_ADDRESS 0x10 // Default I2C address for the VEML7700 sensor
 
typedef enum
{
    VEML7700_SENSITIVITY_x1,
    VEML7700_SENSITIVITY_x2,
    VEML7700_SENSITIVITY_x1_8,
    VEML7700_SENSITIVITY_x1_4,
    VEML7700_SENSITIVITY_INVALID
} VEML7700_sensitivity_mode_t;
 
typedef enum
{
    VEML7700_INTEGRATION_25ms,
    VEML7700_INTEGRATION_50ms,
    VEML7700_INTEGRATION_100ms,
    VEML7700_INTEGRATION_200ms,
    VEML7700_INTEGRATION_400ms,
    VEML7700_INTEGRATION_800ms,
    VEML7700_INTEGRATION_INVALID
} VEML7700_integration_time_t;
 
typedef enum
{
    VEML7700_PERSISTENCE_1,
    VEML7700_PERSISTENCE_2,
    VEML7700_PERSISTENCE_4,
    VEML7700_PERSISTENCE_8,
    VEML7700_PERSISTENCE_INVALID
} VEML7700_persistence_protect_t;
 
typedef enum
{
    VEML7700_INT_DISABLE,
    VEML7700_INT_ENABLE,
    VEML7700_INT_INVALID
} VEML7700_interrupt_enable_t;
typedef enum
{
    VEML7700_INT_STATUS_NONE,
    VEML7700_INT_STATUS_HIGH,
    VEML7700_INT_STATUS_LOW,
    VEML7700_INT_STATUS_BOTH,
    VEML7700_INT_STATUS_INVALID
} VEML7700_interrupt_status_t;
 
typedef enum
{
    VEML7700_POWER_ON,
    VEML7700_SHUT_DOWN,
    VEML7700_SHUTDOWN_INVALID
} VEML7700_shutdown_t;
 
const uint16_t kVEML7700ValueError = 0xFFFF; // Value returned when the VEML7700 is not connected or an error occurs
 
class sfDevVEML7700
{
  public:
    sfDevVEML7700() : _theBus{nullptr}
    {
    }
 
    sfTkError_t begin(sfTkIBus *theBus = nullptr);
 
    bool isConnected();
 
    sfTkError_t setShutdown(bool);
    sfTkError_t powerOn(void)
    {
        return setShutdown(false);
    };
    sfTkError_t shutdown(void)
    {
        return setShutdown(true);
    };
    bool isShutdown(void);
 
    sfTkError_t enableInterrupt(bool);
 
    bool isInterruptEnabled(void);
 
    sfTkError_t setPersistenceProtect(VEML7700_persistence_protect_t pp);
 
    sfTkError_t getPersistenceProtect(VEML7700_persistence_protect_t &pp);
 
    VEML7700_persistence_protect_t persistenceProtect(void);
 
    VEML7700_persistence_protect_t getPersistenceProtect(void)
    {
        return persistenceProtect();
    }
 
    const char *persistenceProtectString(void);
 
    const char *getPersistenceProtectStr(void)
    {
        return persistenceProtectString();
    }
 
    sfTkError_t setIntegrationTime(VEML7700_integration_time_t it);
 
    sfTkError_t getIntegrationTime(VEML7700_integration_time_t &it);
 
    VEML7700_integration_time_t integrationTime(void);
 
    VEML7700_integration_time_t getIntegrationTime(void)
    {
        return integrationTime();
    }
    const char *integrationTimeString(void);
 
    const char *getIntegrationTimeStr(void)
    {
        return integrationTimeString();
    }
 
    sfTkError_t setSensitivityMode(VEML7700_sensitivity_mode_t sm);
 
    sfTkError_t getSensitivityMode(VEML7700_sensitivity_mode_t &sm);
 
    VEML7700_sensitivity_mode_t sensitivityMode(void);
 
    VEML7700_sensitivity_mode_t getSensitivityMode(void)
    {
        return sensitivityMode();
    }
 
    const char *sensitivityModeString(void);
 
    const char *getSensitivityModeStr(void)
    {
        return sensitivityModeString();
    }
 
    sfTkError_t setHighThreshold(uint16_t threshold);
 
    sfTkError_t getHighThreshold(uint16_t &threshold);
 
    uint16_t highThreshold(void);
 
    uint16_t getHighThreshold(void)
    {
        return highThreshold();
    }
 
    sfTkError_t setLowThreshold(uint16_t threshold);
 
    sfTkError_t getLowThreshold(uint16_t &threshold);
 
    uint16_t lowThreshold(void);
 
    uint16_t getLowThreshold(void)
    {
        return lowThreshold();
    } // Get the Low Threshold object - this is for backward compatibility
 
    sfTkError_t getAmbientLight(uint16_t &ambient);
    uint16_t getAmbientLight(void);
 
    sfTkError_t getWhiteLevel(uint16_t &whiteLevel);
    uint16_t getWhiteLevel(void);
 
    sfTkError_t getLux(float &lux);
 
    float getLux(void);
 
    VEML7700_interrupt_status_t interruptStatus(void);
 
    VEML7700_interrupt_status_t getInterruptStatus(void)
    {
        return interruptStatus();
    } // Get the Interrupt Status object - this is for backward compatibility
 
  private:
    typedef struct
    {
        union {
            VEML7700_t all;
            struct
            {
                VEML7700_t CONFIG_REG_SD : 1;     // ALS shut down
                VEML7700_t CONFIG_REG_INT_EN : 1; // ALS interrupt enable
                VEML7700_t CONFIG_REG_RES1 : 2;   // Reserved
                VEML7700_t CONFIG_REG_PERS : 2;   // ALS persistence protect number
                VEML7700_t CONFIG_REG_IT : 4;     // ALS integration time
                VEML7700_t CONFIG_REG_RES2 : 1;   // Reserved
                VEML7700_t CONFIG_REG_SM : 2;     // ALS sensitivity mode
                VEML7700_t CONFIG_REG_RES3 : 3;   // Reserved
            };
        };
    } sfDevVEML7700Config_t;
 
    typedef struct
    {
        union {
            VEML7700_t all;
            struct
            {
                VEML7700_t INT_STATUS_REG_RES : 14; // Reserved
                // Bit 14 indicates if the high threshold was exceeded
                // Bit 15 indicates if the low threshold was exceeded
                VEML7700_t INT_STATUS_REG_INT_FLAGS : 2;
            };
        };
    } VEML7700_INTERRUPT_STATUS_REGISTER_t;
 
    // VEML7700 Registers - note types are uint8_t to match the I2C register size
 
    static constexpr uint8_t VEML7700_CONFIGURATION_REGISTER = 0;
    static constexpr uint8_t VEML7700_HIGH_THRESHOLD = 1;
    static constexpr uint8_t VEML7700_LOW_THRESHOLD = 2;
    static constexpr uint8_t VEML7700_ALS_OUTPUT = 4;
    static constexpr uint8_t VEML7700_WHITE_OUTPUT = 5;
    static constexpr uint8_t VEML7700_INTERRUPT_STATUS = 6;
 
    // ALS integration time setting
    typedef enum
    {
        VEML7700_CONFIG_INTEGRATION_25ms = 0b1100,
        VEML7700_CONFIG_INTEGRATION_50ms = 0b1000,
        VEML7700_CONFIG_INTEGRATION_100ms = 0b0000,
        VEML7700_CONFIG_INTEGRATION_200ms = 0b0001,
        VEML7700_CONFIG_INTEGRATION_400ms = 0b0010,
        VEML7700_CONFIG_INTEGRATION_800ms = 0b0011,
        VEML7700_CONFIG_INTEGRATION_INVALID
    } VEML7700_config_integration_time_t;
 
    sfTkError_t updateConfiguration(sfDevVEML7700Config_t &config);
 
    VEML7700_config_integration_time_t integrationTimeConfig(VEML7700_integration_time_t it);
 
    VEML7700_integration_time_t integrationTimeFromConfig(VEML7700_config_integration_time_t it);
 
    sfTkIBus *_theBus;
};