void begin(void);            				// инициализация шины
void setClock(uint32_t clock);       		// ручная установка частоты шины 31-900 kHz (в герцах)
void beginTransmission(uint8_t address); 	// открыть соединение (для записи данных)
void endTransmission(bool stop = true);  	// закрыть соединение , произвести stop или restart (по умолчанию - stop)
void write(uint8_t data);                	// отправить в шину байт данных , отправка производится сразу , формат - byte "unsigned char"
void requestFrom(uint8_t address , uint8_t length , bool stop = true);  //открыть соединение и запросить данные от устройства
uint8_t read(void);                      	// прочитать байт , БУФЕРА НЕТ!!! , читайте сразу все запрошенные байты , stop или restart после чтения последнего байта, настраивается в requestFrom
uint8_t available(void);                 	// вернет количество оставшихся для чтения байт

	MicroDS3231();	// конструктор
void setTime(uint8_t seconds , uint8_t minutes , uint8_t hours , uint8_t date, uint8_t month, uint16_t year);	// установка времени
void setTime(uint8_t param);	// установка времени == времени компиляции
bool lostPower(void);			// проверка на сброс питания
uint8_t getSeconds(void);		// получить секунды
uint8_t getMinutes(void);		// получить минуты
uint8_t getHours(void);			// получить часы
uint8_t getDay(void);			// получить день недели
uint8_t getDate(void);			// получить число
uint16_t getYear(void);			// получить год
uint8_t getMonth(void);			// получить месяц

Подключается к шине i2c (пины A4 и A5)

• DS3231 -> Arduino
• GND -> GND
• VCC -> VCC
• SDA -> A4
• SCL -> A5

// демо возможностей библиотеки
#include "microDS3231.h"
MicroDS3231 rtc;

void setup() {
  Serial.begin(9600);
  
  if (rtc.lostPower()) {  //  при потере питания
    rtc.setTime(COMPILE_TIME);  // установить время компиляции
  }

  //rtc.setTime(SEC, MIN, HOUR, DAY, MONTH, YEAR); // устанвока времени вручную
}

void loop() {
  printTime();
  delay(500);
}

void printTime() {
  Serial.print(rtc.getHours());
  Serial.print(":");
  Serial.print(rtc.getMinutes());
  Serial.print(":");
  Serial.print(rtc.getSeconds());
  Serial.print(" ");
  Serial.print(rtc.getDay());
  Serial.print(" ");
  Serial.print(rtc.getDate());
  Serial.print("/");
  Serial.print(rtc.getMonth());
  Serial.print("/");
  Serial.println(rtc.getYear());
}

Библиотека является полным аналогом обычной LiquidCrystal_I2C

LiquidCrystal_I2C(uint8_t lcd_Addr,uint8_t lcd_cols,uint8_t lcd_rows);
void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS );
void clear();
void home();
void noDisplay();
void display();
void noBlink();
void blink();
void noCursor();
void cursor();
void scrollDisplayLeft();
void scrollDisplayRight();
void printLeft();
void printRight();
void leftToRight();
void rightToLeft();
void shiftIncrement();
void shiftDecrement();
void noBacklight();
void backlight();
void autoscroll();
void noAutoscroll(); 
void createChar(uint8_t, uint8_t[]);
void createChar(uint8_t location, const char *charmap);

Подключается к шине i2c (пины A4 и A5)

• LCD I2C -> Arduino
• GND -> GND
• VCC -> VCC
• SDA -> A4
• SCL -> A5

#include "microLiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd(0x3f, 20, 4);
// адрес дисплея 0x3f или 0x27
// ширина дисплея (тут 20 символов)
// высота дисплея (тут 4 строки)

void setup()
{
  lcd.init();                      // initialize the lcd
  lcd.init();
  // Print a message to the LCD.
  lcd.backlight();
  lcd.setCursor(3, 0);
  lcd.print("Hello, world!");
  lcd.setCursor(2, 1);
  lcd.print("Ywrobot Arduino!");
  lcd.setCursor(0, 2);
  lcd.print("Arduino LCM IIC 2004");
  lcd.setCursor(2, 3);
  lcd.print("Power By Ec-yuan!");
}

void loop()
{
}

MicroDS18B20(uint8_t pin);    // создать объект
void requestTemp();           // запросить температуру
float getTemp(void);          // получить температуру

Подключается пином data в любой цифровой пин Arduino (у Nano/Uno это D0-D13, A0-A5)

• DS18B20 -> Arduino
• GND -> GND
• VCC -> VCC
• DATA -> D0-D13, A0-A5. Пин дополнительно подтягивается к VCC резистором на 4.7 кОм

#include "microDS18B20.h"

MicroDS18B20 sensor1(2);  // датчик на пине 2
MicroDS18B20 sensor2(3);  // датчик на пине 3

void setup() {
  Serial.begin(9600);  
}

void loop() {
  Serial.print("t: ");
  sensor1.requestTemp();
  sensor2.requestTemp();
  delay(1000);  // между request и get нужна секунда (асинхронный режим)
  Serial.print(sensor1.getTemp());
  Serial.print(" ");
  Serial.println(sensor2.getTemp());
}

Опрос одного датчика с разрешением 12 бит без библиотеки. Работа с датчиком занимает 400 байт Flash (в несколько раз меньше обычной либы)

#define DS_PIN 2  // пин датчика

void setup() {
  Serial.begin(9600);
  dallas_begin(DS_PIN); // инициализация  
}

void loop() {
  dallas_requestTemp(DS_PIN); // запрос
  delay(1000);
  float value = dallas_getTemp(DS_PIN);
  Serial.println(value); // получаем температуру
}

// ======= dallas =======
void dallas_begin(uint8_t pin) {
  pinMode(pin, INPUT);
  digitalWrite(pin, LOW);
}
void dallas_requestTemp(uint8_t pin) {
  if (oneWire_reset(pin)) return;
  oneWire_write(0xCC, pin);
  oneWire_write(0x44, pin);
}
float dallas_getTemp(uint8_t pin) {
  uint8_t data[2];
  if (oneWire_reset(pin)) return;
  oneWire_write(0xCC, pin);
  oneWire_write(0xBE, pin);
  data[0] = oneWire_read(pin);
  data[1] = oneWire_read(pin);
  float result = (float)((data[1] << 8) | data[0]) * 0.0625; //>
  return result;
}

// ======= 1wire =======
boolean oneWire_reset(byte pin) {
  pinMode(pin, 1);
  delayMicroseconds(640);
  pinMode(pin, 0);
  delayMicroseconds(2);
  for (uint8_t c = 80; c; c--) {
    if (!digitalRead(pin)) {
      uint32_t tmr = micros();
      while (!digitalRead(pin)) {
        if (micros() - tmr > 200) return false;
      }
      return false;
    }
    delayMicroseconds(1);
  }
  return true;
}
void oneWire_write(uint8_t data, byte pin) {
  for (uint8_t p = 8; p; p--) {
    pinMode(pin, 1);
    if (data & 1) {
      delayMicroseconds(5);
      pinMode(pin, 0);
      delayMicroseconds(90);
    } else {
      delayMicroseconds(90);
      pinMode(pin, 0);
      delayMicroseconds(5);
    }
    data >>= 1;
  }
}
uint8_t oneWire_read(byte pin) {
  uint8_t data = 0;
  for (uint8_t p = 8; p; p--) {
    data >>= 1;
    pinMode(pin, 1);
    delayMicroseconds(2);
    pinMode(pin, 0);
    delayMicroseconds(8);
    bool dataBit = digitalRead(pin);
    delayMicroseconds(80);
    if (dataBit) data |= 0x80;
  }
  return data;
}

// ============ Методы класса microLED ============
// ЛЕНТА: имя буфера, количество ледов, пин
microLED(LEDdata *LEDarray, int LEDamount, byte pin);

// МАТРИЦА: имя буфера, пин, ширина матрицы, высота матрицы, тип матрицы, угол подключения, направление	(см. ПОДКЛЮЧЕНИЕ МАТРИЦЫ)
microLED(LEDdata *LEDarray, byte pin, byte width, byte height, M_type type, M_connection conn, M_dir dir);

// лента и матрица
void setRGB(int num, byte r, byte g, byte b);   // RGB
void setHSV(int num, byte h, byte s, byte v);   // HSV
void setHEX(int num, uint32_t color);           // HEX
void setColor(int num, COLORS color);           // стандартный цвет (см. "Стандартные цвета")
void colorWheel(int num, int color);            // цвет 0-1530	
void fill(LEDdata color);                       // заливка цветом (mRGB, mWHEEL, mHEX, mHSV)
void setLED(int n, LEDdata color);              // ставим цвет светодиода (mRGB, mWHEEL, mHEX, mHSV)	
uint32_t getColorHEX(int num);                  // получить HEX цвет диода (для сравнения и т.п.)
LEDdata getColor(int num);                      // получить цвет диода в LEDdata
void fade(int num, byte val);                   // уменьшить яркость на val

void setBrightness(byte newBright);             // яркость 0-255
void clear();                                   // очистка
void show();                                    // отправка

// матрица
void setPix(int x, int y, LEDdata color);       // ставим цвет пикселя x y в LEDdata (mRGB, mWHEEL, mHEX, mHSV)
uint32_t getColorHEX(int x, int y);             // получить цвет пикселя в HEX
LEDdata getColor(int x, int y);                 // получить цвет пикселя в LEDdata
void fadePix(int x, int y, byte val);           // уменьшить яркость пикселя на val
uint16_t getPixNumber(int x, int y);            // получить номер пикселя в ленте по координатам

// ============ Функции кодирования цвета ============
LEDdata mRGB(byte r, byte g, byte b);   // RGB 255, 255, 255
LEDdata mWHEEL(int color);              // цвета 0-1530
LEDdata mHEX(uint32_t color);           // HEX цвет
LEDdata mHSV(byte h, byte s, byte v);   // HSV 255, 255, 255
LEDdata mCOLOR(COLORS color);           // цвет

// ==================== Константы ====================
// Стандартные цвета
WHITE
SILVER
GRAY
BLACK
RED
MAROON
YELLOW
ORANGE
OLIVE
LIME
GREEN
AQUA
TEAL
BLUE
NAVY
PINK
PURPLE

// пример работы с лентой
#define LED_PIN 6       // пин ленты
#define NUMLEDS 64       // кол-во светодиодов

#define ORDER_GRB       // порядок цветов ORDER_GRB / ORDER_RGB / ORDER_BRG

#define COLOR_DEBTH 2   // цветовая глубина: 1, 2, 3 (в байтах)
// на меньшем цветовом разрешении скетч будет занимать в разы меньше места,
// но уменьшится и количество оттенков и уровней яркости!

// ВНИМАНИЕ! define настройки (ORDER_GRB и COLOR_DEBTH) делаются до подключения библиотеки!
#include "microLED.h"

LEDdata leds[NUMLEDS];  // буфер ленты типа LEDdata (размер зависит от COLOR_DEBTH)
microLED strip(leds, NUMLEDS, LED_PIN);  // объект лента

void setup() {
  strip.setBrightness(30);    // яркость (0-255)
  // яркость применяется при выводе .show() !

  strip.clear();   // очищает буфер
  // применяется при выводе .show() !
  
  strip.show(); // выводим изменения на ленту

  // Библиотека поддерживает два варианта работы с лентой:
  // изменение цвета конкретного пикселя при помощи готовой функции
  // или работа с массивом "вручную".
  // Чтобы вывести обновлённый массив на ленту, используется .show()

  // ------------------------------------------
  // методы для заливки конкретного пикселя
  // диод 0, цвет RGB 255 0 0 (красный)
  strip.setRGB(0, 255, 0, 0);

  // диод 1, цвет HSV 30 255 255 (цвет 30, яркость и насыщенность максимум)
  strip.setHSV(1, 30, 255, 255);

  // диод 2, цвет HEX 0x30B210
  strip.setHEX(2, 0x30B210);

  // диод 3, цвет AQUA
  strip.setColor(3, AQUA);

  // диод 4, цвет 1200 (диапазон 0-1530 вдоль радуги)
  strip.colorWheel(4, 1200);

  strip.show(); // выводим изменения на ленту
  delay(2000);

  // цвет любого диода можно получить в виде hex кода и сравнить с другим:
  if (strip.getColorHEX(0) == strip.getColorHEX(1));

  // ------------------------------------------
  // данные функции возвращают конвертированный "цвет", который можно присвоить в массив
  // mRGB(r, g, b);  // RGB 255, 255, 255
  // mWHEEL(color);  // цвета 0-1530
  // mHEX(color);    // HEX цвет
  // mHSV(h, s, v);  // HSV 255, 255, 255
  // mCOLOR(color);  // цвет

  // Например покрасим половину ленты в один, половину в другой
  for (byte i = 0; i < NUMLEDS / 2; i++) {
    leds[i] = mHSV(0, 255, 255);  // красный
  }
  for (byte i = NUMLEDS / 2; i < NUMLEDS; i++) {
    leds[i] = mHSV(80, 255, 255); // примерно зелёный
  }
  strip.show(); // выводим изменения на ленту
  delay(2000);

  // ------------------------------------------
  // Также есть метод setLED, который красит диод цветом
  strip.clear();   // очищает буфер
  
  // диод 0, цвет RGB 255 0 0 (красный)  
  strip.setLED(0, mRGB(255, 0, 0));

  // диод 1, цвет HSV 30 255 255 (цвет 30, яркость и насыщенность максимум)
  strip.setLED(1, mHSV(30, 255, 255));

  // диод 2, цвет HEX 0x30B210
  strip.setLED(2, mHEX(0x30B210));

  // диод 3, цвет AQUA
  strip.setLED(3, mCOLOR(AQUA));

  // диод 4, цвет 1200 (диапазон 0-1530 вдоль радуги)
  strip.setLED(4, mWHEEL(1200));
  
  strip.show(); // выводим изменения на ленту
  delay(2000);
  
  // ------------------------------------------
  // Есть готовая функция для заливки всей ленты цветом - .fill()
  // принимает конвертированный цвет, например от функций выше
  strip.fill(mCOLOR(YELLOW)); // заливаем жёлтым
  strip.show(); // выводим изменения на ленту
  delay(2000);

  // ------------------------------------------
  // Для ускорения ручных заливок можно создать переменную типа LEDdata
  LEDdata value1, value2;
  value1 = mHSV(60, 100, 255);
  value2 = mHSV(190, 255, 190);
  for (byte i = 0; i < NUMLEDS; i++) {
    // заливаем по половине ленты
    if (i < NUMLEDS / 2) leds[i] = value1;
    else leds[i] = value2;
  }
  strip.show(); // выводим изменения на ленту
  delay(2000);
  strip.clear();
}

void loop() {
  // радуга!
  static byte counter = 0;
  for (byte i = 0; i < NUMLEDS; i++) {
    //strip.setHSV(i, counter + i * (255 / NUMLEDS), 255, 255);  // можно так
    leds[i] = mHSV(counter + i * (255 / NUMLEDS), 255, 255); // или в стиле fastLED
  }
  counter += 1;
  strip.show();
  delay(20);
}

// пример работы с модулем матрицы 8x8

#define M_WIDTH 8             // ширина матрицы
#define M_HEIGHT 8            // высота матрицы

#define ORDER_GRB       // порядок цветов ORDER_GRB / ORDER_RGB / ORDER_BRG
#define COLOR_DEBTH 2   // цветовая глубина: 1, 2, 3 (в байтах)
// на меньшем цветовом разрешении скетч будет занимать в разы меньше места,
// но уменьшится и количество оттенков и уровней яркости!

// ВНИМАНИЕ! define настройки (ORDER_GRB и COLOR_DEBTH) делаются до подключения библиотеки!
#include "microLED.h"
#define LED_PIN 8       // пин ленты

#define NUM_LEDS M_WIDTH * M_HEIGHT
LEDdata leds[NUM_LEDS];  // буфер ленты типа LEDdata

microLED matrix(leds, LED_PIN, M_WIDTH, M_HEIGHT, PARALLEL, LEFT_TOP, DIR_RIGHT);  // объект матрица
// тип матрицы: ZIGZAG - зигзаг, PARALLEL - параллельная
// угол подключения: LEFT_BOTTOM - левый нижний, LEFT_TOP - левый верхний, RIGHT_TOP - правый верхний, RIGHT_BOTTOM - правый нижний
// направление ленты из угла подключения: DIR_RIGHT - вправо, DIR_UP - вверх, DIR_LEFT - влево, DIR_DOWN - вниз
// шпаргалка по настройке матрицы в папке docs в библиотеке

void setup() {
  matrix.setBrightness(30);  // яркость (0-255)
  // Проверка ориентации матрицы
  // Система координат - декартовая первая четверть
  // Левый нижний угол - жёлтый
  // Левый верхний - пурпурный
  // Правый нижний - голубой

  // рисуем пиксель: setPix(x, y, цвет)
  // цвет в формате LEDdata, то есть:
  // mRGB(r, g, b);  // RGB 255, 255, 255
  // mWHEEL(color);  // цвета 0-1530
  // mHEX(color);    // HEX цвет
  // mHSV(h, s, v);  // HSV 255, 255, 255
  // mCOLOR(color);  // цвет

  matrix.setPix(0, 0, mCOLOR(YELLOW));
  matrix.setPix(0, 7, mCOLOR(PURPLE));
  matrix.setPix(7, 0, mCOLOR(TEAL));
  matrix.show();
  delay(1000);
  matrix.clear();
}

void loop() {
  // примеры эффектов

  //rainbow();    // горизонтальная радуга
  //matrixNeo();  // матрица
  //balls();      // шарики
  confetti();

  matrix.show();
  delay(50);
}

void rainbow() {
  static byte hue = 0;
  hue++;
  for (byte i = 0; i < M_WIDTH; i++) {
    LEDdata thisColor = mHSV((byte)(hue + i * float(255 / M_WIDTH)), 255, 255);
    for (byte j = 0; j < M_HEIGHT; j++)
      matrix.setPix(i, j, thisColor);
  }
}

void matrixNeo() {
  for (byte x = 0; x < M_WIDTH; x++) {
    // заполняем случайно верхнюю строку
    uint32_t thisColor = matrix.getColorHEX(x, M_HEIGHT - 1);
    if (thisColor == 0)
      matrix.setPix(x, M_HEIGHT - 1, mHEX(0x00FF00 * (random(0, 10) == 0)));
    else if (thisColor < 0x002000)
      matrix.setPix(x, M_HEIGHT - 1, mHEX(0));
    else
      matrix.setPix(x, M_HEIGHT - 1, mHEX(thisColor - 0x002000));
  }

  // сдвигаем всё вниз
  for (byte x = 0; x < M_WIDTH; x++) {
    for (byte y = 0; y < M_HEIGHT - 1; y++) {
      // красим пиксель цветом верхнего над ним
      matrix.setPix(x, y, matrix.getColor(x, y + 1));
    }
  }
}

#define BALLS_AMOUNT 5
boolean loadingFlag = true;
int coord[BALLS_AMOUNT][2];
int8_t vector[BALLS_AMOUNT][2];
LEDdata ballColors[BALLS_AMOUNT];

void balls() {
  if (loadingFlag) {
    loadingFlag = false;
    for (byte j = 0; j < BALLS_AMOUNT; j++) {
      int sign;

      // забиваем случайными данными
      coord[j][0] = M_WIDTH / 2 * 10;
      random(0, 2) ? sign = 1 : sign = -1;
      vector[j][0] = random(4, 15) * sign;
      coord[j][1] = M_HEIGHT / 2 * 10;
      random(0, 2) ? sign = 1 : sign = -1;
      vector[j][1] = random(4, 15) * sign;
      ballColors[j] = mHSV(random(0, 9) * 28, 255, 255);
    }
  }

  matrix.clear();  // очистить

  // движение шариков
  for (byte j = 0; j < BALLS_AMOUNT; j++) {
    for (byte i = 0; i < 2; i++) {
      coord[j][i] += vector[j][i];
      if (coord[j][i] < 0) { coord[j][i] = 0; vector[j][i] = -vector[j][i]; } } if (coord[j][0] > (M_WIDTH - 1) * 10) {
      coord[j][0] = (M_WIDTH - 1) * 10;
      vector[j][0] = -vector[j][0];
    }
    if (coord[j][1] > (M_HEIGHT - 1) * 10) {
      coord[j][1] = (M_HEIGHT - 1) * 10;
      vector[j][1] = -vector[j][1];
    }
    matrix.setPix(coord[j][0] / 10, coord[j][1] / 10, ballColors[j]);
  }
}

void confetti() {
  for (int i = 0; i < NUM_LEDS; i++) {
    if (matrix.getColor(i) == 0)
      if (random(0, 30) == 0) matrix.setLED(i, mHSV(random(0, 255), 255, 255));
    matrix.fade(i, 20);
  }
}

	GyverBME280();								// Create an object of class BME280
	bool begin(void);							// Initialize sensor with standard or previously selected parameters
	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()]

/*
   Простой пример, демонстрирующий основные функции измерения температуры, давления и влажности
*/

#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);
}

/*
   Пример индивидуальных настроек датчика под ваше применение
   См. константы в 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);
}

/*
   Пример работы датчика с пониженным энергопотреблением
   По умолчанию - 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);
}

/*
   Пример работы датчика в двух режимах - обычном и принудительном , а так же перезапись настроек во время работы
   О режимах:
   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);
}