ОБЛЕГЧЁННЫЕ БИБЛИОТЕКИ

Сборник лёгких библиотек для Arduino и некоторых модулей, в разработке находятся ещё несколько, позже будут добавлены сюда.

БИБЛИОТЕКА MICRO WIRE

Лёгкая библиотека с минимальным набором инструментов для работы с модулями по шине I2C для микроконтроллеров поколения ATmega328

  • Не является полноценным аналогом библиотеки Wire!!!
  • Нужна для работы i2с библиотек из сборника на этой странице!
  • Не все библиотеки на Wire смогут работать с microWire (не является заменой Wire)
  • microWire создана для работы с устройствами в ручном режиме
  • Разработано by Egor ‘Nich1con’ Zaharov
	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);                 	// вернет количество оставшихся для чтения байт

БИБЛИОТЕКА MICRO DS3231

Ультра лёгкая библиотека для работы с RTC DS3231

  • Для работы нужна библиотека microWire.h
  • Разработано by Egor ‘Nich1con’ Zaharov
	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());
}

БИБЛИОТЕКА MICRO LCD i2c

Библиотека для LCD дисплея с переходником на I2C, облегчена за счёт использования microWire вместо Wire

  • Для работы нужна библиотека microWire.h

Библиотека является полным аналогом обычной 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()
{
}

БИБЛИОТЕКА MICRO DS18B20

Лёгкая версия библиотеки для работы с датчиком температуры Dallas ds18b20, занимает гораздо меньше места в памяти, чем стандартная. Поддерживаемые платформы: все Arduino
Разработано by Egor, допилено AlexGyver

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

Ультра-лёгкая библиотека для работы с адресной лентой, полное описание читай на отдельной странице.

  • Основная фишка: сжатие цвета, код занимает в разы меньше места в SRAM по сравнению с аналогами (FastLED, NeoPixel и др.)
    • Использование 8 битного цвета занимает в 3 раза меньше SRAM чем у других библиотек
    • Использование 16 битного цвета занимает в 1.5 раза меньше SRAM чем у других библиотек
  • Поддержка сжатия цвета: 8, 16 и 24 бита
  • Поддержка порядка цветов: RGB, GRB, BRG
  • Работа с цветом: RGB, HSV, HEX цвета, Цветовое колесо, 16 встроенных цветов
  • Возможность чтения сжатого цвета в HEX 0xRRGGBB
  • Функция уменьшения яркости одного пикселя
  • Поддержка работы с адресными матрицами (см. пример)
  • Поддержка чипов: 2811/2812, остальные не проверялись
  • Частичная совместимость со скетчами для FastLED (смотри пример fastToMicro)

Поддерживаемые платформы: тестировалось только на ATmega328 (Nano, UNO, Mini) и ATtiny85. Должны поддерживаться и остальные МК этого поколения, частота желательно 16 МГц.

// ============ Методы класса 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);
}
}

БИБЛИОТЕКА GYVER BME280

Лёгкая библиотека для работы с датчиком BME280

  • Легче аналогов =)
  • Разработано by Egor ‘Nich1con’ Zaharov

Поддерживаемые платформы: все Arduino

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

 

ОСТАЛЬНЫЕ БИБЛИОТЕКИ

У меня есть ещё очень много всего интересного! Смотрите полный список библиотек вот здесь.