ErriezBH1750.cpp

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2020 Erriez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include "ErriezBH1750.h"
#include "ErriezBH1750_regs.h"

BH1750::BH1750(uint8_t addrPinLevel) : _completionTimestamp(0)
{
    if (addrPinLevel == HIGH) {
        _i2cAddr = BH1750_I2C_ADDR_H;
    } else {
        _i2cAddr = BH1750_I2C_ADDR_L;
    }
}

void BH1750::begin(BH1750_Mode_e mode, BH1750_Resolution_e resolution)
{
    // Store mode and resolution in variable.
    // Mode will be send in startConversion()
    _mode = (mode & BH1750_MODE_MASK) | (resolution & BH1750_RES_MASK);

    // Power down
    powerDown();
}

void BH1750::powerDown()
{
    _completionTimestamp = 0;
    writeInstruction(BH1750_POWER_DOWN);
}

void BH1750::startConversion()
{
    if (IS_INITIALIZED(_mode)) {
        writeInstruction(_mode);
        setTimestamp();
    }
}

bool BH1750::isConversionCompleted()
{
    if (IS_INITIALIZED(_mode) == false) {
        return false;
    }

    if (_completionTimestamp && (millis() >= _completionTimestamp)) {
        return true;
    } else {
        return false;
    }
}

bool BH1750::waitForCompletion()
{
    uint8_t timeout;

    if (IS_INITIALIZED(_mode) == false) {
        return false;
    }

    if (IS_LOW_RESOLUTION(_mode) == true) {
        timeout = BH1750_CONV_TIME_L;
    } else {
        timeout = BH1750_CONV_TIME_H;
    }

    // Check if conversion completed in a loop
    // Wait additional 2m
    for (uint8_t i = 0; i < (timeout + 2); i++) {
        if (isConversionCompleted()) {
            return true;
        }
        delay(1);
    }

    return false;
}

uint16_t BH1750::read()
{
    uint16_t level;

    // Check operation mode
    if (IS_INITIALIZED(_mode) == false) {
        return 0;
    }

    if (IS_ONE_TIME_MODE(_mode)) {
        // Clear conversion in one-time mode
        // Application should call startConversion() again
        _completionTimestamp = 0;
    } else if (IS_CONTINUES_MODE(_mode)) {
        setTimestamp();
    }

    // Read two bytes from sensor
    Wire.requestFrom((int) _i2cAddr, 2);

    // Read low and high bytes
    level = (uint16_t) Wire.read();
    level <<= 8;
    level |= (uint8_t) Wire.read();

    //level = 0b1000001110010000; // 28067 lx
    //level = 0b0000000100010000; // 227 lx
    //level = 0b0000000000010010; // 7.5 lx

    // Convert raw value to LUX
    level = ((((uint32_t) level) * 10) + 5) / 12;

    return level;
}

//------------------------------------------------------------------------------
// Protected functions
//------------------------------------------------------------------------------
void BH1750::setTimestamp()
{
    _completionTimestamp = millis() + GET_TIMEOUT(_mode);
}

void BH1750::writeInstruction(uint8_t instruction)
{
    Wire.beginTransmission(_i2cAddr);
    Wire.write(instruction);
    Wire.endTransmission();
}