gogacoder/GyverBME280
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add

Browse Source
This commit is contained in:
Alex
2021-05-25 00:15:25 +03:00
parent 34300db7e6
commit df0090efa4
9 changed files with 673 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
README.md Normal file
View File

@@ -0,0 +1,130 @@
![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)
![author](https://img.shields.io/badge/author-AlexGyver-informational.svg)
# GyverBME280
Лёгкая библиотека для работы с BME280 по I2C для Arduino
### Совместимость
Совместима со всеми Arduino платформами (используются Arduino-функции)
## Содержание
- [Установка](#install)
- [Инициализация](#init)
- [Использование](#usage)
- [Пример](#example)
- [Версии](#versions)
- [Баги и обратная связь](#feedback)
<a id="install"></a>
## Установка
- Библиотеку можно найти по названию **GyverBME280** и установить через менеджер библиотек в:
- Arduino IDE
- Arduino IDE v2
- PlatformIO
- [Скачать библиотеку](https://github.com/GyverLibs/GyverBME280/archive/refs/heads/main.zip) .zip архивом для ручной установки:
- Распаковать и положить в *C:\Program Files (x86)\Arduino\libraries* (Windows x64)
- Распаковать и положить в *C:\Program Files\Arduino\libraries* (Windows x32)
- Распаковать и положить в *Документы/Arduino/libraries/*
- (Arduino IDE) автоматическая установка из .zip: *Скетч/Подключить библиотеку/Добавить .ZIP библиотеку…* и указать скачанный архив
- Читай более подробную инструкцию по установке библиотек [здесь](https://alexgyver.ru/arduino-first/#%D0%A3%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0_%D0%B1%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA)
<a id="init"></a>
## Инициализация
```cpp
GyverBME280 bme;
```
<a id="usage"></a>
## Использование
```cpp
bool begin(void); // запустить со стандартным адресом (0x76)
bool begin(uint8_t address); // запустить с указанием адреса
bool isMeasuring(void); // возвращает true, пока идёт измерение
float readPressure(void); // прочитать давление в Па
float readHumidity(void); // Прочитать влажность в %
void oneMeasurement(void); // Сделать одно измерение и уйти в сон
float readTemperature(void); // Прочитать температуру в градусах С
void setMode(uint8_t mode); // установить режим работы
// режимы:
NORMAL_MODE
FORCED_MODE
void setFilter(uint8_t mode); // изменить коэффициент фильтрации. Вызывать перед begin
// коэффициенты:
FILTER_DISABLE
FILTER_COEF_2
FILTER_COEF_4
FILTER_COEF_8
FILTER_COEF_16
void setStandbyTime(uint8_t mode); // Изменить время между измерениями. Вызывать перед begin
// режимы:
STANDBY_500US
STANDBY_10MS
STANDBY_20MS
STANDBY_6250US
STANDBY_125MS
STANDBY_250MS
STANDBY_500MS
STANDBY_1000MS
void setHumOversampling(uint8_t mode); // Настроить оверсэмплинг или отключить влажность. Вызывать перед begin
void setTempOversampling(uint8_t mode); // Настроить оверсэмплинг или отключить температуру. Вызывать перед begin
void setPressOversampling(uint8_t mode); // Настроить оверсэмплинг или отключить давление. Вызывать перед begin
// режимы:
MODULE_DISABLE
OVERSAMPLING_1
OVERSAMPLING_2
OVERSAMPLING_4
OVERSAMPLING_8
OVERSAMPLING_16
```
<a id="example"></a>
## Пример
Остальные примеры смотри в **examples**!
```cpp
/*
Простой пример, демонстрирующий основные функции измерения температуры, давления и влажности
*/
#include <GyverBME280.h> // Подключение библиотеки
GyverBME280 bme; // Создание обьекта bme
void setup() {
Serial.begin(9600); // Запуск последовательного порта
bme.begin(); // Если доп. настройки не нужны - инициализируем датчик
}
void loop() {
Serial.print("Temperature: ");
Serial.print(bme.readTemperature()); // Выводим темперутуру в [*C]
Serial.println(" *C");
Serial.print("Humidity: ");
Serial.print(bme.readHumidity()); // Выводим влажность в [%]
Serial.println(" %");
float pressure = bme.readPressure(); // Читаем давление в [Па]
Serial.print("Pressure: ");
Serial.print(pressure / 100.0F); // Выводим давление в [гПа]
Serial.print(" hPa , ");
Serial.print(pressureToMmHg(pressure)); // Выводим давление в [мм рт. столба]
Serial.println(" mm Hg");
Serial.print("Altitide: ");
Serial.print(pressureToAltitude(pressure)); // Выводим высоту в [м над ур. моря]
Serial.println(" m");
Serial.println("");
delay(1000);
}
```
<a id="versions"></a>
## Версии
- v1.3 - исправлена ошибка при отриц. температуре
- v1.4 - разбил на h и cpp
<a id="feedback"></a>
## Баги и обратная связь
При нахождении багов создавайте **Issue**, а лучше сразу пишите на почту [alex@alexgyver.ru](mailto:alex@alexgyver.ru)
Библиотека открыта для доработки и ваших **Pull Request**'ов!

33
examples/custom_setup/custom_setup.ino Normal file
View File

@@ -0,0 +1,33 @@
/*
Пример индивидуальных настроек датчика под ваше применение
См. константы в GyverBME280.h , стандартные настройки можно изменить там же в классе GyverMBE280
Настройки вступают в силу только ПОСЛЕ .begin();
*/
#include <GyverBME280.h> // Подключение библиотеки
GyverBME280 bme; // Создание обьекта bme
void setup() {
Serial.begin(9600); // Запуск последовательного порта
bme.setFilter(FILTER_COEF_8); // Настраиваем коофициент фильтрации
bme.setTempOversampling(OVERSAMPLING_8); // Настраиваем передискретизацию для датчика температуры
bme.setPressOversampling(OVERSAMPLING_16); // Настраиваем передискретизацию для датчика давления
bme.setStandbyTime(STANDBY_500MS); // Устанавливаем время сна между измерениями (у нас обычный циклический режим)
bme.begin(); // Если на этом настройки окончены - инициализируем датчик
}
void loop() {
Serial.print("Temperature: ");
Serial.print(bme.readTemperature()); // Выводим темперутуру в [*C]
Serial.println(" *C");
Serial.print("Humidity: ");
Serial.print(bme.readHumidity()); // Выводим влажность в [%]
Serial.println(" %");
Serial.print("Pressure: ");
Serial.print(pressureToMmHg(bme.readPressure())); // Выводим давление в мм рт. столба
Serial.println(" mm Hg");
Serial.println("");
delay(1000);
}

31
examples/low_power/low_power.ino Normal file
View File

@@ -0,0 +1,31 @@
/*
Пример работы датчика с пониженным энергопотреблением
По умолчанию - NORMAL_MODE - Время сна между преобразованиями - 250мс
См. константы в GyverBME280.h , стандартные настройки можно изменить там же в классе GyverMBE280
Настройки вступают в силу только ПОСЛЕ .begin();
*/
#include <GyverBME280.h> // Подключение библиотеки
GyverBME280 bme; // Создание обьекта bme
void setup() {
Serial.begin(9600); // Запуск последовательного порта
bme.setHumOversampling(MODULE_DISABLE); // Отключаем неиспользуемый модуль измерения влажности - экономим энергию
// bme.setMode(FORCED_MODE); // По возможности используем принудительный режим с редким опросом
bme.setStandbyTime(STANDBY_1000MS); // Если используем обычный режим - увеличиваем время сна между измерениями насколько это возможно в нашем случае
bme.begin(); // Если на этом настройки окончены - инициализируем датчик
}
void loop() {
// bme.oneMeasurement(); // Если используем принудительный мод - необходимо будить датчик для проведения измерения
// while (bme.isMeasuring()); // И дождаться окончания текущего измерения , чтобы не взять устаревшие данные
Serial.print("Temperature: ");
Serial.print(bme.readTemperature()); // Выводим темперутуру в [*C]
Serial.println(" *C");
Serial.print("Pressure: ");
Serial.print(pressureToMmHg(bme.readPressure())); // Выводим давление в мм рт. столба
Serial.println(" mm Hg");
Serial.println("");
delay(1000);
}

57
examples/modes/modes.ino Normal file
View File

@@ -0,0 +1,57 @@
/*
Пример работы датчика в двух режимах - обычном и принудительном , а так же перезапись настроек во время работы
О режимах:
NORMAL_MODE - Обычный - датчик делает измерения циклически , между измерениями спит , время сна настраивается с помощью .setStandbyTime(); , см пример low_power
FORCED_MODE - Принудительный - датчик спит , после вызова .oneMeasurement(); просыпается и делает ОДНО преобразование , после чего уходит в сон
По умолчанию - NORMAL_MODE - Время сна между преобразованиями - 250мс
См. константы в GyverBME280.h , стандартные настройки можно изменить там же в классе GyverMBE280
*/
#include <GyverBME280.h> // Подключение библиотеки
GyverBME280 bme; // Создание обьекта bme
void setup() {
Serial.begin(9600); // Запуск последовательного порта
bme.setMode(FORCED_MODE); // Перед инициализацией говорим датчику работать в принудительном режиме
bme.begin(); // Больше настройки не нужны - инициализируем датчик
while (millis() < 10000) { // Работа с датчиком в принудительном режиме в течении первых 10 секунд
bme.oneMeasurement(); // Просим датчик проснуться и сделать одно преобразование
while (bme.isMeasuring()); // Ждем окончания преобразования
Serial.print("Temperature: ");
Serial.print(bme.readTemperature()); // Читаем и выводим температуру
Serial.println(" *C");
Serial.print("Humidity: ");
Serial.print(bme.readHumidity()); // Читаем и выводим влажность
Serial.println(" %");
Serial.print("Pressure: ");
Serial.print(pressureToMmHg(bme.readPressure())); // Читаем и выводим давление
Serial.println(" mm Hg");
Serial.println("");
delay(1000);
}
bme.setMode(NORMAL_MODE); // Спустя 10 секунд переключаем датчик в обычный режим
bme.begin(); // Переинициализируем датчик после изменения настроек - обязательная процедура
}
void loop() { // Работа с датчиком в обычном режиме , преобразования идут в цикличном режиме
Serial.print("Temperature: ");
Serial.print(bme.readTemperature()); // Читаем и выводим температуру
Serial.println(" *C");
Serial.print("Humidity: ");
Serial.print(bme.readHumidity()); // Читаем и выводим влажность
Serial.println(" %");
Serial.print("Pressure: ");
Serial.print(pressureToMmHg(bme.readPressure())); // Читаем и выводим давление
Serial.println(" mm Hg");
Serial.println("");
delay(1000);
}

33
examples/simple/simple.ino Normal file
View File

@@ -0,0 +1,33 @@
/*
Простой пример, демонстрирующий основные функции измерения температуры, давления и влажности
*/
#include <GyverBME280.h> // Подключение библиотеки
GyverBME280 bme; // Создание обьекта bme
void setup() {
Serial.begin(9600); // Запуск последовательного порта
bme.begin(); // Если доп. настройки не нужны - инициализируем датчик
}
void loop() {
Serial.print("Temperature: ");
Serial.print(bme.readTemperature()); // Выводим темперутуру в [*C]
Serial.println(" *C");
Serial.print("Humidity: ");
Serial.print(bme.readHumidity()); // Выводим влажность в [%]
Serial.println(" %");
float pressure = bme.readPressure(); // Читаем давление в [Па]
Serial.print("Pressure: ");
Serial.print(pressure / 100.0F); // Выводим давление в [гПа]
Serial.print(" hPa , ");
Serial.print(pressureToMmHg(pressure)); // Выводим давление в [мм рт. столба]
Serial.println(" mm Hg");
Serial.print("Altitide: ");
Serial.print(pressureToAltitude(pressure)); // Выводим высоту в [м над ур. моря]
Serial.println(" m");
Serial.println("");
delay(1000);
}

52
keywords.txt Normal file
View File

@@ -0,0 +1,52 @@
#######################################
# Syntax Coloring Map For GyverBME280
#######################################
#######################################
# Datatypes (KEYWORD1)
#######################################
GyverBME280 KEYWORD1
#######################################
# Methods and Functions (KEYWORD2)
#######################################
begin KEYWORD2
isMeasuring KEYWORD2
setFilter KEYWORD2
setMode KEYWORD2
setStandbyTime KEYWORD2
setHumOversampling KEYWORD2
setTempOversampling KEYWORD2
setPressOversampling KEYWORD2
oneMeasurement KEYWORD2
readTemperature KEYWORD2
readPressure KEYWORD2
readHumidity KEYWORD2
pressureToAltitude KEYWORD2
pressureToMmHg KEYWORD2
#######################################
# Constants (LITERAL1)
#######################################
NORMAL_MODE LITERAL1
FORCED_MODE LITERAL1
STANDBY_500US LITERAL1
STANDBY_10MS LITERAL1
STANDBY_20MS LITERAL1
STANDBY_6250US LITERAL1
STANDBY_125MS LITERAL1
STANDBY_250MS LITERAL1
STANDBY_500MS LITERAL1
STANDBY_1000MS LITERAL1
MODULE_DISABLE LITERAL1
OVERSAMPLING_1 LITERAL1
OVERSAMPLING_2 LITERAL1
OVERSAMPLING_4 LITERAL1
OVERSAMPLING_8 LITERAL1
OVERSAMPLING_16 LITERAL1
FILTER_DISABLE LITERAL1
FILTER_COEF_2 LITERAL1
FILTER_COEF_4 LITERAL1
FILTER_COEF_8 LITERAL1
FILTER_COEF_16 LITERAL1

9
library.properties Normal file
View File

@@ -0,0 +1,9 @@
name=GyverBME280
version=1.4
author=AlexGyver <alex@alexgyver.ru>
maintainer=AlexGyver <alex@alexgyver.ru>
sentence=Light library for BME280 sensor
paragraph=Light library for BME280 sensor
category=Sensors
url=https://github.com/GyverLibs/GyverBME280
architectures=*

217
src/GyverBME280.cpp Normal file
View File

@@ -0,0 +1,217 @@
#include "GyverBME280.h"
/* ============ Utilities ============ */
float pressureToAltitude(float pressure) {
if(!pressure) return 0; // If the pressure module has been disabled return '0'
pressure /= 100.0F; // Convert [Pa] to [hPa]
return 44330.0 * (1.0 - pow(pressure / 1013.25, 0.1903)); // Сalculate altitude
}
float pressureToMmHg(float pressure) {
return (float)(pressure * 0.00750061683f); // Convert [Pa] to [mm Hg]
}
/* ============ Setup & begin ============ */
bool GyverBME280::begin(void) {
return GyverBME280::begin(0x76);
}
bool GyverBME280::begin(uint8_t address) {
_i2c_address = address;
/* === Start I2C bus & check BME280 === */
Wire.begin(); // Start I2C bus
if(!GyverBME280::reset()) return false; // BME280 software reset & ack check
if(GyverBME280::readRegister(0xD0) != 0x60) return false; // Check chip ID
GyverBME280::readCalibrationData(); // Read all calibration values
/* === Load settings to BME280 === */
GyverBME280::writeRegister(0xF2 , _hum_oversampl); // write hum oversampling value
GyverBME280::writeRegister(0xF2 , GyverBME280::readRegister(0xF2)); // rewrite hum oversampling register
GyverBME280::writeRegister(0xF4 , ((_temp_oversampl << 5) | (_press_oversampl << 2) | _operating_mode)); // write temp & press oversampling value , normal mode
GyverBME280::writeRegister(0xF5 , ((_standby_time << 5) | (_filter_coef << 2))); // write standby time & filter coef
return true;
}
void GyverBME280::setMode(uint8_t mode) {
_operating_mode = mode;
}
void GyverBME280::setFilter(uint8_t mode) {
_filter_coef = mode;
}
void GyverBME280::setStandbyTime(uint8_t mode) {
_standby_time = mode;
}
void GyverBME280::setHumOversampling(uint8_t mode) {
_hum_oversampl = mode;
}
void GyverBME280::setTempOversampling(uint8_t mode) {
_temp_oversampl = mode;
}
void GyverBME280::setPressOversampling(uint8_t mode) {
_press_oversampl = mode;
}
/* ============ Reading ============ */
int32_t GyverBME280::readTempInt(void) {
int32_t temp_raw = GyverBME280::readRegister24(0xFA); // Read 24-bit value
if (temp_raw == 0x800000) return 0; // If the temperature module has been disabled return '0'
temp_raw >>= 4; // Start temperature reading in integers
int32_t value_1 = ((((temp_raw >> 3) - ((int32_t)CalibrationData._T1 << 1))) *
((int32_t)CalibrationData._T2)) >> 11;
int32_t value_2 = (((((temp_raw >> 4) - ((int32_t)CalibrationData._T1)) *
((temp_raw >> 4) - ((int32_t)CalibrationData._T1))) >> 12) * ((int32_t)CalibrationData._T3)) >> 14;
return ((int32_t)value_1 + value_2); // Return temperature in integers
}
float GyverBME280::readTemperature(void) {
int32_t temp_raw = GyverBME280::readTempInt();
float T = (temp_raw * 5 + 128) >> 8;
return T / 100; // Return temperature in float
}
float GyverBME280::readPressure(void) {
uint32_t press_raw = GyverBME280::readRegister24(0xF7); // Read 24-bit value
if (press_raw == 0x800000) return 0; // If the pressure module has been disabled return '0'
press_raw >>= 4; // Start pressure converting
int64_t value_1 = ((int64_t)GyverBME280::readTempInt()) - 128000;
int64_t value_2 = value_1 * value_1 * (int64_t)CalibrationData._P6;
value_2 = value_2 + ((value_1 * (int64_t)CalibrationData._P5) << 17);
value_2 = value_2 + (((int64_t)CalibrationData._P4) << 35);
value_1 = ((value_1 * value_1 * (int64_t)CalibrationData._P3) >> 8) + ((value_1 * (int64_t)CalibrationData._P2) << 12);
value_1 = (((((int64_t)1) << 47) + value_1)) * ((int64_t)CalibrationData._P1) >> 33;
if (!value_1) return 0; // Avoid division by zero
int64_t p = 1048576 - press_raw;
p = (((p << 31) - value_2) * 3125) / value_1;
value_1 = (((int64_t)CalibrationData._P9) * (p >> 13) * (p >> 13)) >> 25;
value_2 = (((int64_t)CalibrationData._P8) * p) >> 19;
p = ((p + value_1 + value_2) >> 8) + (((int64_t)CalibrationData._P7) << 4);
return (float)p / 256; // Return pressure in float
}
float GyverBME280::readHumidity(void) {
Wire.beginTransmission(_i2c_address); // Start I2C transmission
Wire.write(0xFD); // Request humidity data register
if(Wire.endTransmission() != 0) return 0;
Wire.requestFrom(_i2c_address, 2); // Request humidity data
int32_t hum_raw = ((uint16_t)Wire.read() << 8) | (uint16_t)Wire.read(); // Read humidity data
if (hum_raw == 0x8000) return 0; // If the humidity module has been disabled return '0'
int32_t value = (GyverBME280::readTempInt() - ((int32_t)76800)); // Start humidity converting
value = (((((hum_raw << 14) - (((int32_t)CalibrationData._H4) << 20) -
(((int32_t)CalibrationData._H5) * value)) +((int32_t)16384)) >> 15) *
(((((((value * ((int32_t)CalibrationData._H6)) >> 10) *(((value *
((int32_t)CalibrationData._H3)) >> 11) + ((int32_t)32768))) >> 10) +
((int32_t)2097152)) * ((int32_t)CalibrationData._H2) + 8192) >> 14));
value = (value - (((((value >> 15) * (value >> 15)) >> 7) * ((int32_t)CalibrationData._H1)) >> 4));
value = (value < 0) ? 0 : value;
value = (value > 419430400) ? 419430400 : value;
float h = (value >> 12);
return h / 1024.0; // Return humidity in float
}
/* ============ Misc ============ */
bool GyverBME280::isMeasuring(void) {
return (bool)((GyverBME280::readRegister(0xF3) & 0x08) >> 3); // Read status register & mask bit "measuring"
}
void GyverBME280::oneMeasurement(void) {
GyverBME280::writeRegister(0xF4 , ((GyverBME280::readRegister(0xF4) & 0xFC) | 0x02)); // Set the operating mode to FORCED_MODE
}
GyverBME280::GyverBME280() {}
/* ============ Private ============ */
/* = BME280 software reset = */
bool GyverBME280::reset(void) {
if(!GyverBME280::writeRegister(0x0E , 0xB6)) return false;
delay(10);
return true;
}
/* = Read and combine three BME280 registers = */
uint32_t GyverBME280::readRegister24(uint8_t address) {
Wire.beginTransmission(_i2c_address);
Wire.write(address);
if(Wire.endTransmission() != 0) return 0x800000;
Wire.requestFrom(_i2c_address, 3);
return (((uint32_t)Wire.read() << 16) | ((uint32_t)Wire.read() << 8) | (uint32_t)Wire.read());
}
/* = Write one 8-bit BME280 register = */
bool GyverBME280::writeRegister(uint8_t address , uint8_t data) {
Wire.beginTransmission(_i2c_address);
Wire.write(address);
Wire.write(data);
if(Wire.endTransmission() != 0) return false;
return true;
}
/* = Read one 8-bit BME280 register = */
uint8_t GyverBME280::readRegister(uint8_t address) {
Wire.beginTransmission(_i2c_address);
Wire.write(address);
if(Wire.endTransmission() != 0) return 0;
Wire.requestFrom(_i2c_address , 1);
return Wire.read();
}
/* = Structure to store all calibration values = */
void GyverBME280::readCalibrationData(void) {
/* first part request*/
Wire.beginTransmission(_i2c_address);
Wire.write(0x88);
if(Wire.endTransmission() != 0) return;
Wire.requestFrom(_i2c_address , 25);
/* reading */
CalibrationData._T1 = (Wire.read() | (Wire.read() << 8));
CalibrationData._T2 = (Wire.read() | (Wire.read() << 8));
CalibrationData._T3 = (Wire.read() | (Wire.read() << 8));
CalibrationData._P1 = (Wire.read() | (Wire.read() << 8));
CalibrationData._P2 = (Wire.read() | (Wire.read() << 8));
CalibrationData._P3 = (Wire.read() | (Wire.read() << 8));
CalibrationData._P4 = (Wire.read() | (Wire.read() << 8));
CalibrationData._P5 = (Wire.read() | (Wire.read() << 8));
CalibrationData._P6 = (Wire.read() | (Wire.read() << 8));
CalibrationData._P7 = (Wire.read() | (Wire.read() << 8));
CalibrationData._P8 = (Wire.read() | (Wire.read() << 8));
CalibrationData._P9 = (Wire.read() | (Wire.read() << 8));
CalibrationData._H1 = Wire.read();
/* second part request*/
Wire.beginTransmission(_i2c_address);
Wire.write(0xE1);
Wire.endTransmission();
Wire.requestFrom(_i2c_address , 8);
/* reading */
CalibrationData._H2 = (Wire.read() | (Wire.read() << 8));
CalibrationData._H3 = Wire.read();
CalibrationData._H4 = (Wire.read() << 4);
uint8_t interVal = Wire.read();
CalibrationData._H4 |= (interVal & 0xF);
CalibrationData._H5 = (((interVal & 0xF0) >> 4) | (Wire.read() << 4));
CalibrationData._H6 = Wire.read();
}

111
src/GyverBME280.h Normal file
View File

@@ -0,0 +1,111 @@
/*
Лёгкая библиотека для работы с BME280 по I2C для Arduino
Документация:
GitHub: https://github.com/GyverLibs/GyverBME280
Egor 'Nich1con' Zaharov for AlexGyver, alex@alexgyver.ru
https://alexgyver.ru/
MIT License
Версии:
v1.3 - исправлена ошибка при отриц. температуре
v1.4 - разбил на h и cpp
*/
#ifndef GyverBME280_h
#define GyverBME280_h
#include <Arduino.h>
#include <Wire.h>
#define NORMAL_MODE 0x03
#define FORCED_MODE 0x02
#define STANDBY_500US 0x00
#define STANDBY_10MS 0x06
#define STANDBY_20MS 0x07
#define STANDBY_6250US 0x01
#define STANDBY_125MS 0x02
#define STANDBY_250MS 0x03
#define STANDBY_500MS 0x04
#define STANDBY_1000MS 0x05
#define MODULE_DISABLE 0x00
#define OVERSAMPLING_1 0x01
#define OVERSAMPLING_2 0x02
#define OVERSAMPLING_4 0x03
#define OVERSAMPLING_8 0x04
#define OVERSAMPLING_16 0x05
#define FILTER_DISABLE 0x00
#define FILTER_COEF_2 0x01
#define FILTER_COEF_4 0x02
#define FILTER_COEF_8 0x03
#define FILTER_COEF_16 0x04
// ================================= CLASS ===================================
class GyverBME280 {
public:
GyverBME280(); // Create an object of class BME280
bool begin(void); // Initialize sensor with standart 0x76 address
bool begin(uint8_t address); // Initialize sensor with not standart 0x76 address
bool isMeasuring(void); // Returns 'true' while the measurement is in progress
float readPressure(void); // Read and calculate atmospheric pressure [float , Pa]
float readHumidity(void); // Read and calculate air humidity [float , %]
void oneMeasurement(void); // Make one measurement and go back to sleep [FORCED_MODE only]
void setMode(uint8_t mode);
float readTemperature(void); // Read and calculate air temperature [float , *C]
void setFilter(uint8_t mode); // Adjust the filter ratio other than the standard one [before begin()]
void setStandbyTime(uint8_t mode); // Adjust the sleep time between measurements [NORMAL_MODE only][before begin()]
void setHumOversampling(uint8_t mode); // Set oversampling or disable humidity module [before begin()]
void setTempOversampling(uint8_t mode); // Set oversampling or disable temperature module [before begin()]
void setPressOversampling(uint8_t mode); // Set oversampling or disable pressure module [before begin()]
private:
//============================== DEFAULT SETTINGS ========================================|
int _i2c_address = 0x76; // BME280 address on I2C bus |
uint8_t _operating_mode = NORMAL_MODE; // Sensor operation mode |
uint8_t _standby_time = STANDBY_250MS; // Time between measurements in NORMAL_MODE |
uint8_t _filter_coef = FILTER_COEF_16; // Filter ratio IIR |
uint8_t _temp_oversampl = OVERSAMPLING_4; // Temperature module oversampling parameter |
uint8_t _hum_oversampl = OVERSAMPLING_1; // Humidity module oversampling parameter |
uint8_t _press_oversampl = OVERSAMPLING_2; // Pressure module oversampling parameter |
//========================================================================================|
bool reset(void); // BME280 software reset
int32_t readTempInt(); // Temperature reading in integers for the function of reading
void readCalibrationData(void); // Read all cells containing calibration values
uint8_t readRegister(uint8_t address); // Read one 8-bit BME280 register
uint32_t readRegister24(uint8_t address); // Read and combine three BME280 registers
bool writeRegister(uint8_t address , uint8_t data); // Write one 8-bit BME280 register
struct { // Structure to store all calibration values
uint16_t _T1;
int16_t _T2;
int16_t _T3;
uint16_t _P1;
int16_t _P2;
int16_t _P3;
int16_t _P4;
int16_t _P5;
int16_t _P6;
int16_t _P7;
int16_t _P8;
int16_t _P9;
uint8_t _H1;
int16_t _H2;
uint8_t _H3;
int16_t _H4;
int16_t _H5;
int8_t _H6;
} CalibrationData;
};
float pressureToMmHg(float pressure); // Convert [Pa] to [mm Hg]
float pressureToAltitude(float pressure); // Convert pressure to altitude
#endif