diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

LiquidCrystalSerial
Adafruit BME280 Library
BH1750

libraries.txt

// Темп, влажность, освещенность, давление -> 2004 - ua1zki@mail.ru  2022-dec-17  OKF
// все ус-ва на I2C шине
// https://wokwi.com/projects/351822277697864277
//01 lat
//02 rus                          221219
//home clear 2000                     23
//04 font i2c test                230107
//noDisplay Display                   08


#define NAME              "UA1ZKI: BME280, BH1750 -> 2004"
#define VERSION           "0.4"
#define UART_BAUDRATE     9600

#define _LCD_TYPE         1             //I2c LCD
#define TEMP_POS          0,0           //позиции LCD
#define HUMIDITY_POS      0,1
#define LIGHT_POS         0,2
#define PRESSURE_POS      0,3

#define PERIOD            10000         //период измерения, ms


#include <Wire.h>
#include "Adafruit_BME280.h"
#include "BH1750.h"
#include "LCD_1602_RUS_ALL.h"


Adafruit_BME280   bme;                  //0x76
BH1750            light;                //0x23
LCD_1602_RUS      lcd(0x27, 20, 4);


void sensor() {
  lcd.setCursor(TEMP_POS);
  lcd.print("  Темп. ");                //  __мп.
  lcd.print(bme.readTemperature(), 2);
  lcd.print(" *C   ");

  lcd.setCursor(HUMIDITY_POS);
  lcd.print("  Влажн. ");                // _л_жн.
  lcd.print(bme.readHumidity(), 2);
  lcd.print(" %    ");

  lcd.setCursor(LIGHT_POS);
  lcd.print("  Освещ. ");                // __в_щ.
  lcd.print((uint16_t)light.readLightLevel(), DEC);
  lcd.print(" Lux   ");

  lcd.setCursor(PRESSURE_POS);
  lcd.print("  Давл.  ");                //  Д___.
  // lcd.print(bme.readPressure() / 100.0F, 2);
  lcd.print(1022.8, 2);
  lcd.print(" hPa  ");
}


void setup() {
  Serial.begin(UART_BAUDRATE);
  Serial.println(F(NAME "\r\n V." VERSION " " __DATE__ " " __TIME__ "\r\n"));

  if (!bme.begin())
    Serial.println(F("Not find a BME280 sensor!"));
  light.begin();
  lcd.init();
  lcd.backlight();

  // lcd.noDisplay();
  // sensor();
  // sensor();
  // lcd.display();
}


void loop() {
  sensor();
  delay(PERIOD);
}


sketch.ino

#ifndef _LCD_1602_RUS_FONT
#define _LCD_1602_RUS_FONT

struct {
  uint8_t _rastr[8];//Растровое изображение символа
  uint16_t _unicode;//Код символа в unicode
} const symbol_image[] PROGMEM = { //Набор изображений кириллических символов
{{//Б
  0b11111,
  0b10000,
  0b10000,
  0b11110,
  0b10001,
  0b10001,
  0b11110,
  0b00000
}, 1041},
{{//Г
  0b11111,
  0b10000,
  0b10000,
  0b10000,
  0b10000,
  0b10000,
  0b10000,
  0b00000
}, 1043},
{{//Д
  0b00110,
  0b01010,
  0b01010,
  0b01010,
  0b01010,
  0b01010,
  0b11111,
  0b10001
}, 1044},
{{//Ж
  0b10101,
  0b10101,
  0b10101,
  0b01110,
  0b10101,
  0b10101,
  0b10101,
  0b00000
}, 1046},
{{//З
  0b01110,
  0b10001,
  0b00001,
  0b00110,
  0b00001,
  0b10001,
  0b01110,
  0b00000
}, 1047},
{{//И
  0b10001,
  0b10001,
  0b10001,
  0b10011,
  0b10101,
  0b11001,
  0b10001,
  0b00000
}, 1048},
{{//Й
  0b10101,
  0b10001,
  0b10001,
  0b10011,
  0b10101,
  0b11001,
  0b10001,
  0b00000
}, 1049},
{{//Л
  0b00111,
  0b01001,
  0b01001,
  0b01001,
  0b01001,
  0b01001,
  0b10001,
  0b00000
}, 1051},
{{//П
  0b11111,
  0b10001,
  0b10001,
  0b10001,
  0b10001,
  0b10001,
  0b10001,
  0b00000
}, 1055},
{{//У
  0b10001,
  0b10001,
  0b10001,
  0b01111,
  0b00001,
  0b10001,
  0b01110,
  0b00000
}, 1059},
{{//Ф
  0b00100,
  0b01110,
  0b10101,
  0b10101,
  0b10101,
  0b01110,
  0b00100,
  0b00000
}, 1060},
{{//Ц
  0b10010,
  0b10010,
  0b10010,
  0b10010,
  0b10010,
  0b10010,
  0b11111,
  0b00001
}, 1062},
{{//Ч
  0b10001,
  0b10001,
  0b10001,
  0b01111,
  0b00001,
  0b00001,
  0b00001,
  0b00000
}, 1063},
{{//Ш
  0b10001,
  0b10001,
  0b10001,
  0b10101,
  0b10101,
  0b10101,
  0b11111,
  0b00000
}, 1064},
{{//Щ
  0b10001,
  0b10001,
  0b10001,
  0b10101,
  0b10101,
  0b10101,
  0b11111,
  0b00001
}, 1065},
{{//Ъ
  0b11000,
  0b01000,
  0b01000,
  0b01110,
  0b01001,
  0b01001,
  0b01110,
  0b00000
}, 1066},
{{//Ы
  0b10001,
  0b10001,
  0b10001,
  0b11101,
  0b10011,
  0b10011,
  0b11101,
  0b00000
}, 1067},
{{//Ь
  0b10000,
  0b10000,
  0b10000,
  0b11110,
  0b10001,
  0b10001,
  0b11110,
  0b00000
}, 1068},
{{//Э
  0b01110,
  0b10001,
  0b00001,
  0b00111,
  0b00001,
  0b10001,
  0b01110,
  0b00000
}, 1069},
{{//Ю
  0b10010,
  0b10101,
  0b10101,
  0b11101,
  0b10101,
  0b10101,
  0b10010,
  0b00000
}, 1070},
{{//Я
  0b01111,
  0b10001,
  0b10001,
  0b01111,
  0b00101,
  0b01001,
  0b10001,
  0b00000
}, 1071},
{{//б
  0b00011,
  0b01100,
  0b10000,
  0b11110,
  0b10001,
  0b10001,
  0b01110,
  0b00000
}, 1073},
{{//в
  0b00000,
  0b00000,
  0b11110,
  0b10001,
  0b11110,
  0b10001,
  0b11110,
  0b00000
}, 1074},
{{//г
  0b00000,
  0b00000,
  0b11110,
  0b10000,
  0b10000,
  0b10000,
  0b10000,
  0b00000
}, 1075},
{{//д
  0b00000,
  0b00000,
  0b00110,
  0b01010,
  0b01010,
  0b01010,
  0b11111,
  0b10001
}, 1076},
{{//ё
  0b01010,
  0b00000,
  0b01110,
  0b10001,
  0b11111,
  0b10000,
  0b01111,
  0b00000
}, 1105},
{{//ж
  0b00000,
  0b00000,
  0b10101,
  0b10101,
  0b01110,
  0b10101,
  0b10101,
  0b00000
}, 1078},
{{//з
  0b00000,
  0b00000,
  0b01110,
  0b10001,
  0b00110,
  0b10001,
  0b01110,
  0b00000
}, 1079},
{{//и
  0b00000,
  0b00000,
  0b10001,
  0b10011,
  0b10101,
  0b11001,
  0b10001,
  0b00000
}, 1080},
{{//й
  0b01010,
  0b00100,
  0b10001,
  0b10011,
  0b10101,
  0b11001,
  0b10001,
  0b00000
}, 1081},
{{//к
  0b00000,
  0b00000,
  0b10010,
  0b10100,
  0b11000,
  0b10100,
  0b10010,
  0b00000
}, 1082},
{{//л
  0b00000,
  0b00000,
  0b00111,
  0b01001,
  0b01001,
  0b01001,
  0b10001,
  0b00000
}, 1083},
{{//м
  0b00000,
  0b00000,
  0b10001,
  0b11011,
  0b10101,
  0b10001,
  0b10001,
  0b00000
}, 1084},
{{//н
  0b00000,
  0b00000,
  0b10001,
  0b10001,
  0b11111,
  0b10001,
  0b10001,
  0b00000
}, 1085},
{{//п
  0b00000,
  0b00000,
  0b11111,
  0b10001,
  0b10001,
  0b10001,
  0b10001,
  0b00000
}, 1087},
{{//т
  0b00000,
  0b00000,
  0b11111,
  0b00100,
  0b00100,
  0b00100,
  0b00100,
  0b00000
}, 1090},
{{//ф
  0b00000,
  0b00000,
  0b00100,
  0b01110,
  0b10101,
  0b01110,
  0b00100,
  0b00000
}, 1092},
{{//ц
  0b00000,
  0b00000,
  0b10010,
  0b10010,
  0b10010,
  0b10010,
  0b11111,
  0b00001
}, 1094},
{{//ч
  0b00000,
  0b00000,
  0b10001,
  0b10001,
  0b01111,
  0b00001,
  0b00001,
  0b00000
}, 1095},
{{//ш
  0b00000,
  0b00000,
  0b10101,
  0b10101,
  0b10101,
  0b10101,
  0b11111,
  0b00000
}, 1096},
{{//щ
  0b00000,
  0b00000,
  0b10101,
  0b10101,
  0b10101,
  0b10101,
  0b11111,
  0b00001
}, 1097},
{{//ъ
  0b00000,
  0b00000,
  0b11000,
  0b01000,
  0b01110,
  0b01001,
  0b01110,
  0b00000
}, 1098},
{{//ы
  0b00000,
  0b00000,
  0b10001,
  0b10001,
  0b11101,
  0b10011,
  0b11101,
  0b00000
}, 1099},
{{//ь
  0b00000,
  0b00000,
  0b10000,
  0b10000,
  0b11110,
  0b10001,
  0b11110,
  0b00000
}, 1100},
{{//э
  0b00000,
  0b00000,
  0b01110,
  0b10001,
  0b00111,
  0b10001,
  0b01110,
  0b00000
}, 1101},
{{//ю
  0b00000,
  0b00000,
  0b10010,
  0b10101,
  0b11101,
  0b10101,
  0b10010,
  0b00000
}, 1102},
{{//я
  0b00000,
  0b00000,
  0b01111,
  0b10001,
  0b01111,
  0b00101,
  0b01001,
  0b00000
}, 1103},
//
//Украинские буквы
//
{{//укр. Г
  0b00001,
  0b11111,
  0b10000,
  0b10000,
  0b10000,
  0b10000,
  0b10000,
  0b00000
}, 0x490},
{{//укр. г
  0b00000,
  0b00010,
  0b11110,
  0b10000,
  0b10000,
  0b10000,
  0b10000,
  0b00000
}, 0x491},
{{//укр. Е
  0b01111,
  0b10000,
  0b10000,
  0b11110,
  0b10000,
  0b10000,
  0b01111,
  0b00000
}, 0x404},
{{//укр. е
  0b00000,
  0b00000,
  0b01110,
  0b10000,
  0b11100,
  0b10000,
  0b01110,
  0b00000
}, 0x454},
{{//укр. I
  0b01010,
  0b00000,
  0b01110,
  0b00100,
  0b00100,
  0b00100,
  0b01110,
  0b00000
}, 0x407},
{{//укр. i
  0b00000,
  0b01010,
  0b00000,
  0b01100,
  0b00100,
  0b00100,
  0b01110,
  0b00000
}, 0x457}
};

#endif


font_LCD_1602_RUS.h

#ifndef _LCD_1602_RUS_ALL_h
#define _LCD_1602_RUS_ALL_h

//#define _LCD_TYPE Тип подключения дисплея: 1 - по шине I2C, 2 - десятиконтактное. Обязательно указывать ДО подключения библиотеки
//Если этого не сделать, при компиляции возникнет ошибка: "LCD type connect has not been declared"
#if (_LCD_TYPE != 1)&&(_LCD_TYPE != 2)
#error "LCD type connect has not been declared"
#endif

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

#if defined(ESP8266) || defined(ESP32)
#include <pgmspace.h>
#else
#include <avr/pgmspace.h>
#endif
#if (_LCD_TYPE == 1) //Подключение по I2C
#define LCD_LIB LiquidCrystal_I2C
#define LCD_LIB_H "LiquidCrystal_I2C.h"
#elif (_LCD_TYPE == 2) //Подключение 10-контактное
#define LCD_LIB LiquidCrystal
#define LCD_LIB_H "LiquidCrystal.h"
#endif
#include LCD_LIB_H
#include <Print.h>
#include <Wire.h>
#include "font_LCD_1602_RUS.h"

#ifdef ARDUINO_ARCH_AVR
typedef uint32_t _uint_farptr_t;
#else
typedef uint8_t* _uint_farptr_t;
#ifndef memcpy_PF
#define memcpy_PF(dest, src, len) memcpy_P((dest), (src), (len))
#endif
#endif

//Описание класса набора изменяемых символов
class Symbol {
  public:
    Symbol (uint16_t _code)//Конструктор с начальной инициализацией класса по коду символа в unicode
    {
      index = 255;//Начальная инициализация (неинициализированы = 255)
      code = _code;
    }

    _uint_farptr_t getBitmap()//указатель на растровое изображение символа в дальней памяти. Для работы с таким указателем необходимо использовать функцию memcpy_PF(...)
    {
      uint16_t _tmp_unicode;

      for (uint8_t i = 0; i < ((sizeof(symbol_image)) / (sizeof(symbol_image[0]))); i++)
      {
        memcpy_PF(&_tmp_unicode, (_uint_farptr_t)&symbol_image[i]._unicode, sizeof(_tmp_unicode));//Загрузка значения из дальней памяти
        if (_tmp_unicode == code)
          return (_uint_farptr_t)symbol_image[i]._rastr;
      }
      return (_uint_farptr_t)0xFF;//Возвращает 255 при отсутствии совпадения (ошибка)
    }

    uint8_t index;
    uint16_t code;//Код символа в unicode
};

//Описание класса LCD_1602_RUS
//user_custom_symbols - количество символов, доступное пользователю для использования в своих целях (не более 8)
//Всего переопределяемых символов в LCD - 8.
//Символы с индексом от 0 до (7 - user_custom_symbols) используются библиотекой
//Символы с индексом от (8 - user_custom_symbols) до 7 - можно переопределять пользователю
//По умолчанию количество переопределяемых символов равно 0
class LCD_1602_RUS : public LCD_LIB {
  public:
#if (_LCD_TYPE == 1)
    LCD_1602_RUS (uint8_t lcd_Addr, uint8_t lcd_cols, uint8_t lcd_rows, uint8_t user_custom_symbols = 0) : LCD_LIB (lcd_Addr, lcd_cols, lcd_rows) { //Конструктор для подключения I2C
      init_priv(user_custom_symbols);
    }
#elif (_LCD_TYPE == 2)
    LCD_1602_RUS (uint8_t rs,  uint8_t enable,
                  uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t user_custom_symbols = 0) : LCD_LIB (rs, enable, d0, d1, d2, d3) { //Конструктор для подключения 10-pin
      init_priv(user_custom_symbols);
    }
#endif

#ifdef FDB_LIQUID_CRYSTAL_I2C_H
#if defined(ARDUINO_ESP8266_ESP01) //Для ESP8266-01
    void init(uint8_t _sda = SDA, uint8_t _scl = SCL) {
      Wire.pins(_sda, _scl);
      LCD_LIB::begin();
    }
#else
    void init() {
      LCD_LIB::begin();
    }
#endif
#elif defined(ARDUINO_ESP8266_ESP01)  //Для ESP8266-01
    void init(uint8_t _sda = SDA, uint8_t _scl = SCL) {
      Wire.pins(_sda, _scl);
      LCD_LIB::init();
    }
#endif

    void print(const wchar_t* _str) {
      int current_char  = 0;
      int size = 0;

      //Определяем длину строки (количество символов)
      size = wStrlen((uint8_t*)_str);
      /*while (_str[size] != 0)
      {
        size++;
      }*/

      while (current_char < size)
      {
        printwc(_str[current_char]);
        current_char++;
        cursor_col++;
      }
    }
    void print(const char *c_str) {
      wchar_t _str;
      int current_char = 0;
      int size = strlen(c_str);

      while (current_char < size)
      {
        current_char += mbtowc(&_str, (char *)c_str + current_char, 2);
        printwc(_str);
        cursor_col++;
      }
    }
    void print(const String & str) {
      wchar_t _str;
      const char *c_str = str.c_str();
      int current_char = 0;
      int size = str.length();

      while (current_char < size)
      {
        current_char += mbtowc(&_str, (char*)c_str + current_char, 2);
        printwc(_str);
        cursor_col++;
      }
    }

    template <typename T> void print(T val, int base) {
      cursor_col += LCD_LIB::print(val, base);
    }

    void clear() {
      LCD_LIB::clear();
      ResetAllIndex();
    }

    void setCursor(uint8_t col, uint8_t row) {
      cursor_col = col;
      cursor_row = row;
      LCD_LIB::setCursor(cursor_col, cursor_row);
    }

    uint8_t getCursorCol() {
      return cursor_col;
    }

    uint8_t getCursorRow() {
      return cursor_row;
    }

    //Возвращает длину строки для символов, кодируемых двумя и более байтами (unicode, UTF-8)
    int wStrlen(uint8_t *data) {
      int i = 0;
      int count = 0;
      while (data[i]) {
        if ((data[i] & 0xC0) != 0x80)
          count++;
        i++;
      }
      return count;
    }

    //Перевод символа из кодировки ASCII в Win1251 (для печати расширенных русских символов на LCD)
    wchar_t *ascii_win1251(unsigned char ascii) {
      if (ascii == 168) *char_utf8 = 0x401; //код ASCII буквы Ё (0xA8)
      else if (ascii == 184) *char_utf8 = 0x451; //код ASCII буквы ё (0xB8)
      else if (ascii == 165) *char_utf8 = 0x490; //код Ukr. ASCII буквы Г (0xA5)
      else if (ascii == 180) *char_utf8 = 0x491; //код Ukr. ASCII буквы г (0xB4)
      else if (ascii == 170) *char_utf8 = 0x404; //код Ukr. ASCII буквы Е (0xAA)
      else if (ascii == 186) *char_utf8 = 0x454; //код Ukr. ASCII буквы е (0xBA)
      else if (ascii == 175) *char_utf8 = 0x407; //код Ukr. ASCII буквы I (0xAF)
      else if (ascii == 191) *char_utf8 = 0x457; //код Ukr. ASCII буквы i (0xBF)
      else if (ascii >= 192) //остальные буквы русского алфавита
      {
        *char_utf8 = ascii + 848;
      }
      else *char_utf8 = ascii;

      return char_utf8;
    }
    //Перевод символа из кодировки ASCII в UTF-8 (для печати расширенных русских символов на LCD)
    //*ascii - указатель на массив из двух байт
    wchar_t *ascii_utf8(unsigned char *ascii) {
      if (ascii[0] > 0x7F)
      { //Кириллица
        if ((ascii[0] == 0xD0) && (ascii[1] == 0x81)) *char_utf8 = 0x401; //код ASCII буквы Ё (0xD081)
        else if ((ascii[0] == 0xD1) && (ascii[1] == 0x91)) *char_utf8 = 0x451; //код ASCII буквы ё (0xD191)
        else if ((ascii[0] == 0xD2) && (ascii[1] == 0x90)) *char_utf8 = 0x490; //код Ukr. ASCII буквы Г (0xD290)
        else if ((ascii[0] == 0xD2) && (ascii[1] == 0x91)) *char_utf8 = 0x491; //код Ukr. ASCII буквы г (0xD291)
        else if ((ascii[0] == 0xD0) && (ascii[1] == 0x84)) *char_utf8 = 0x404; //код Ukr. ASCII буквы Е (0xD084)
        else if ((ascii[0] == 0xD1) && (ascii[1] == 0x94)) *char_utf8 = 0x454; //код Ukr. ASCII буквы е (0xD194)
        else if ((ascii[0] == 0xD0) && (ascii[1] == 0x87)) *char_utf8 = 0x407; //код Ukr. ASCII буквы I (0xD087)
        else if ((ascii[0] == 0xD1) && (ascii[1] == 0x97)) *char_utf8 = 0x457; //код Ukr. ASCII буквы i (0xD087)
        else if ((ascii[0] == 0xD0) && (ascii[1] >= 0x90) && (ascii[1] <= 0xBF)) //остальные буквы русского алфавита (А...Я а...п)
        {
          *char_utf8 = ascii[1] + 896;
        }
        else if ((ascii[0] == 0xD1) && (ascii[1] >= 0x80) && (ascii[1] <= 0x8F)) //остальные буквы русского алфавита (р...я)
        {
          *char_utf8 = ascii[1] + 960;
        }
      }
      else
      { //Латиница
        *char_utf8 = ascii[0];
      }
      return char_utf8;
    }

    void ResetAllIndex() {
      symbol_index = 0;
      for (uint8_t i = 0; i < ((sizeof(font)) / (sizeof(font[0]))); i++)
        font[i].index = 255;
    }

  private:
    void init_priv(uint8_t _user_custom_symbols) { //Инициализация конструктора
      max_symbol_count = 8 - _user_custom_symbols;
      cursor_col = 0;
      cursor_row = 0;
      ResetAllIndex();//Сброс значений индексов (неинициализированы = 255)
    }

    uint8_t getIndex(uint16_t unicode) { //Функция возвращает индекс символа в массиве font по передаваемому в функцию коду unicode
      //unicode - код символа в unicode
      for (uint8_t i = 0; i < ((sizeof(font)) / (sizeof(font[0]))); i++)
      {
        if (unicode == font[i].code)
          return i;
      }
      return 0xFF;//Возвращает 255 при отсутствии совпадения (ошибка)
    }

    void CharSetToLCD(uint8_t *array, uint8_t *index) { //Загрузка растрового изображения символа в LCD
      uint8_t x, y;

      if (*index == 255) // Если символ еще не создан, то создаем
      {
        x = getCursorCol();
        y = getCursorRow();
        LCD_LIB::createChar(symbol_index, (uint8_t *)array);// Создаем символ на текущем (по очереди) месте в знакогенераторе (от 0 до MAX_SYMBOL_COUNT)
        setCursor(x, y);
        LCD_LIB::write(symbol_index);// Выводим символ на экран
        //Запомианем, что букве соответствует определенный индекс
        *index = symbol_index;
        symbol_index++;
        if (symbol_index >= max_symbol_count)
        {
          ResetAllIndex();
        }
      }
      else   //Иначе печатаем уже существующий
        LCD_LIB::write(*index);
    }

    void printwc(const wchar_t _chr) {
      uint8_t rus_[8];

      if (_chr < 128) //Английский алфавит без изменения
        LCD_LIB::print((char)_chr);
      else
        //Кириллица
        //Единовременно может быть заменено только 8 символов
        switch (_chr)
        {
          //Русский алфавит, использующий одинаковые с английским алфавитом символы
          case 1040: //А
            LCD_LIB::print("A");
            break;
          case 1042: //В
            LCD_LIB::print("B");
            break;
          case 1045: //Е
            LCD_LIB::print("E");
            break;
          case 1025: //Ё
            LCD_LIB::print("E");
            break;
          case 1050: //К
            LCD_LIB::print("K");
            break;
          case 1052: //M
            LCD_LIB::print("M");
            break;
          case 1053: //H
            LCD_LIB::print("H");
            break;
          case 1054: //O
            LCD_LIB::print("O");
            break;
          case 1056: //P
            LCD_LIB::print("P");
            break;
          case 1057: //C
            LCD_LIB::print("C");
            break;
          case 1058: //T
            LCD_LIB::print("T");
            break;
          case 1061: //X
            LCD_LIB::print("X");
            break;
          case 1072: //а
            LCD_LIB::print("a");
            break;
          case 1077: //е
            LCD_LIB::print("e");
            break;
          case 1086: //o
            LCD_LIB::print("o");
            break;
          case 1088: //p
            LCD_LIB::print("p");
            break;
          case 1089: //c
            LCD_LIB::print("c");
            break;
          case 1091: //y
            LCD_LIB::print("y");
            break;
          case 1093: //x
            LCD_LIB::print("x");
            break;
          case 0x00B0: //Знак градуса
            LCD_LIB::write(223);
            break;
          default:
            //Русский алфавит, требующий новых символов
            memcpy_PF(rus_, (_uint_farptr_t)font[getIndex(_chr)].getBitmap(), 8);
            CharSetToLCD((uint8_t *)rus_, &font[getIndex(_chr)].index);
            break;
        }
    }

    uint8_t mbtowc(wchar_t *_chr, char *_str, uint8_t mb_num) {
      if (mb_num != 2) return 0;
      if ((_str[0] & 0xC0) == 0xC0 && (_str[1] & 0x80) == 0x80) {
        *_chr = ((_str[0] & 0x1F) << 6) + (_str[1] & 0x3F);
        return 2;
      }
      else {
        *_chr = _str[0];
        return 1;
      }
    }

    uint8_t max_symbol_count;  //Максимальное количество переназначаемых символов (по умолчанию 8: от 0 до 7)
    int symbol_index;//Индекс символа (от 0 до MAX_SYMBOL_COUNT)
    uint8_t cursor_col;
    uint8_t cursor_row;
    wchar_t char_utf8[2] = {0};
    Symbol font[53] = { //Переменная font - набор изменияемых символов
      1041, //Б
      1043, //Г
      1044, //Д
      1046, //Ж
      1047, //З
      1048, //И

      1049, //Й
      1051, //Л
      1055, //П
      1059, //У
      1060, //Ф

      1062, //Ц
      1063, //Ч
      1064, //Ш
      1065, //Щ

      1066, //Ъ
      1067, //Ы
      1068, //Ь
      1069, //Э
      1070, //Ю
      1071, //Я

      1073, //б
      1074, //в
      1075, //г
      1076, //д
      1105, //ё
      1078, //ж

      1079, //з
      1080, //и
      1081, //й
      1082, //к
      1083, //л

      1084, //м
      1085, //н
      1087, //п
      1090, //т

      1092, //ф
      1094, //ц
      1095, //ч
      1096, //ш
      1097, //щ
      1098, //ъ

      1099, //ы
      1100, //ь
      1101, //э
      1102, //ю
      1103, //я

      0x490, //Укр. Г
      0x491, //укр. г
      0x404, //укр Е
      0x454, //укр е
      0x407, //укр I
      0x457 //укр i
    };
};

#endif


LCD_1602_RUS_ALL.h

// Based on the work by DFRobot

#include "LiquidCrystal_I2C.h"
#include <inttypes.h>
#if defined(ARDUINO) && ARDUINO >= 100

#include "Arduino.h"

#define printIIC(args)	Wire.write(args)
inline size_t LiquidCrystal_I2C::write(uint8_t value) {
	send(value, Rs);
	return 1;
}

#else
#include "WProgram.h"

#define printIIC(args)	Wire.send(args)
inline void LiquidCrystal_I2C::write(uint8_t value) {
	send(value, Rs);
}

#endif
#include "Wire.h"



// When the display powers up, it is configured as follows:
//
// 1. Display clear
// 2. Function set: 
//    DL = 1; 8-bit interface data 
//    N = 0; 1-line display 
//    F = 0; 5x8 dot character font 
// 3. Display on/off control: 
//    D = 0; Display off 
//    C = 0; Cursor off 
//    B = 0; Blinking off 
// 4. Entry mode set: 
//    I/D = 1; Increment by 1
//    S = 0; No shift 
//
// Note, however, that resetting the Arduino doesn't reset the LCD, so we
// can't assume that its in that state when a sketch starts (and the
// LiquidCrystal constructor is called).

LiquidCrystal_I2C::LiquidCrystal_I2C(uint8_t lcd_Addr,uint8_t lcd_cols,uint8_t lcd_rows)
{
  _Addr = lcd_Addr;
  _cols = lcd_cols;
  _rows = lcd_rows;
  _backlightval = LCD_NOBACKLIGHT;
}

void LiquidCrystal_I2C::init(){
	init_priv();
}

void LiquidCrystal_I2C::init_priv()
{
	Wire.begin();
	_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
	begin(_cols, _rows);  
}

void LiquidCrystal_I2C::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {
	if (lines > 1) {
		_displayfunction |= LCD_2LINE;
	}
	_numlines = lines;

	// for some 1 line displays you can select a 10 pixel high font
	if ((dotsize != 0) && (lines == 1)) {
		_displayfunction |= LCD_5x10DOTS;
	}

	// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
	// according to datasheet, we need at least 40ms after power rises above 2.7V
	// before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
	delay(50); 
  
	// Now we pull both RS and R/W low to begin commands
	expanderWrite(_backlightval);	// reset expanderand turn backlight off (Bit 8 =1)
	delay(1000);

  	//put the LCD into 4 bit mode
	// this is according to the hitachi HD44780 datasheet
	// figure 24, pg 46
	
	  // we start in 8bit mode, try to set 4 bit mode
   write4bits(0x03 << 4);
   delayMicroseconds(4500); // wait min 4.1ms
   
   // second try
   write4bits(0x03 << 4);
   delayMicroseconds(4500); // wait min 4.1ms
   
   // third go!
   write4bits(0x03 << 4); 
   delayMicroseconds(150);
   
   // finally, set to 4-bit interface
   write4bits(0x02 << 4); 


	// set # lines, font size, etc.
	command(LCD_FUNCTIONSET | _displayfunction);  
	
	// turn the display on with no cursor or blinking default
	_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
	display();
	
	// clear it off
	clear();
	
	// Initialize to default text direction (for roman languages)
	_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
	
	// set the entry mode
	command(LCD_ENTRYMODESET | _displaymode);
	
	home();
  
}

/********** high level commands, for the user! */
void LiquidCrystal_I2C::clear(){
	command(LCD_CLEARDISPLAY);// clear display, set cursor position to zero
	delayMicroseconds(2000);  // this command takes a long time!
}

void LiquidCrystal_I2C::home(){
	command(LCD_RETURNHOME);  // set cursor position to zero
	delayMicroseconds(2000);  // this command takes a long time!
}

void LiquidCrystal_I2C::setCursor(uint8_t col, uint8_t row){
	int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
	if ( row > _numlines ) {
		row = _numlines-1;    // we count rows starting w/0
	}
	command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}

// Turn the display on/off (quickly)
void LiquidCrystal_I2C::noDisplay() {
	_displaycontrol &= ~LCD_DISPLAYON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::display() {
	_displaycontrol |= LCD_DISPLAYON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turns the underline cursor on/off
void LiquidCrystal_I2C::noCursor() {
	_displaycontrol &= ~LCD_CURSORON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::cursor() {
	_displaycontrol |= LCD_CURSORON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turn on and off the blinking cursor
void LiquidCrystal_I2C::noBlink() {
	_displaycontrol &= ~LCD_BLINKON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::blink() {
	_displaycontrol |= LCD_BLINKON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// These commands scroll the display without changing the RAM
void LiquidCrystal_I2C::scrollDisplayLeft(void) {
	command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void LiquidCrystal_I2C::scrollDisplayRight(void) {
	command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}

// This is for text that flows Left to Right
void LiquidCrystal_I2C::leftToRight(void) {
	_displaymode |= LCD_ENTRYLEFT;
	command(LCD_ENTRYMODESET | _displaymode);
}

// This is for text that flows Right to Left
void LiquidCrystal_I2C::rightToLeft(void) {
	_displaymode &= ~LCD_ENTRYLEFT;
	command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'right justify' text from the cursor
void LiquidCrystal_I2C::autoscroll(void) {
	_displaymode |= LCD_ENTRYSHIFTINCREMENT;
	command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'left justify' text from the cursor
void LiquidCrystal_I2C::noAutoscroll(void) {
	_displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
	command(LCD_ENTRYMODESET | _displaymode);
}

// Allows us to fill the first 8 CGRAM locations
// with custom characters
void LiquidCrystal_I2C::createChar(uint8_t location, uint8_t charmap[]) {
	location &= 0x7; // we only have 8 locations 0-7
	command(LCD_SETCGRAMADDR | (location << 3));
	for (int i=0; i<8; i++) {
		write(charmap[i]);
	}
}

//createChar with PROGMEM input
void LiquidCrystal_I2C::createChar(uint8_t location, const char *charmap) {
	location &= 0x7; // we only have 8 locations 0-7
	command(LCD_SETCGRAMADDR | (location << 3));
	for (int i=0; i<8; i++) {
	    	write(pgm_read_byte_near(charmap++));
	}
}

// Turn the (optional) backlight off/on
void LiquidCrystal_I2C::noBacklight(void) {
	_backlightval=LCD_NOBACKLIGHT;
	expanderWrite(0);
}

void LiquidCrystal_I2C::backlight(void) {
	_backlightval=LCD_BACKLIGHT;
	expanderWrite(0);
}



/*********** mid level commands, for sending data/cmds */

inline void LiquidCrystal_I2C::command(uint8_t value) {
	send(value, 0);
}


/************ low level data pushing commands **********/

// write either command or data
void LiquidCrystal_I2C::send(uint8_t value, uint8_t mode) {
	uint8_t highnib=value&0xf0;
	uint8_t lownib=(value<<4)&0xf0;
       write4bits((highnib)|mode);
	write4bits((lownib)|mode); 
}

void LiquidCrystal_I2C::write4bits(uint8_t value) {
	expanderWrite(value);
	pulseEnable(value);
}

void LiquidCrystal_I2C::expanderWrite(uint8_t _data){                                        
	Wire.beginTransmission(_Addr);
	printIIC((int)(_data) | _backlightval);
	Wire.endTransmission();   
}

void LiquidCrystal_I2C::pulseEnable(uint8_t _data){
	expanderWrite(_data | En);	// En high
	delayMicroseconds(1);		// enable pulse must be >450ns
	
	expanderWrite(_data & ~En);	// En low
	delayMicroseconds(50);		// commands need > 37us to settle
} 


// Alias functions

void LiquidCrystal_I2C::cursor_on(){
	cursor();
}

void LiquidCrystal_I2C::cursor_off(){
	noCursor();
}

void LiquidCrystal_I2C::blink_on(){
	blink();
}

void LiquidCrystal_I2C::blink_off(){
	noBlink();
}

void LiquidCrystal_I2C::load_custom_character(uint8_t char_num, uint8_t *rows){
		createChar(char_num, rows);
}

void LiquidCrystal_I2C::setBacklight(uint8_t new_val){
	if(new_val){
		backlight();		// turn backlight on
	}else{
		noBacklight();		// turn backlight off
	}
}

void LiquidCrystal_I2C::printstr(const char c[]){
	//This function is not identical to the function used for "real" I2C displays
	//it's here so the user sketch doesn't have to be changed 
	print(c);
}


// unsupported API functions
void LiquidCrystal_I2C::off(){}
void LiquidCrystal_I2C::on(){}
void LiquidCrystal_I2C::setDelay (int cmdDelay,int charDelay) {}
uint8_t LiquidCrystal_I2C::status(){return 0;}
uint8_t LiquidCrystal_I2C::keypad (){return 0;}
uint8_t LiquidCrystal_I2C::init_bargraph(uint8_t graphtype){return 0;}
void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end){}
void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_row_end){}
void LiquidCrystal_I2C::setContrast(uint8_t new_val){}

	


LiquidCrystal_I2C.cpp

//YWROBOT
#ifndef LiquidCrystal_I2C_h
#define LiquidCrystal_I2C_h

#include <inttypes.h>
#include "Print.h" 
#include <Wire.h>

// commands
#define LCD_CLEARDISPLAY 0x01
#define LCD_RETURNHOME 0x02
#define LCD_ENTRYMODESET 0x04
#define LCD_DISPLAYCONTROL 0x08
#define LCD_CURSORSHIFT 0x10
#define LCD_FUNCTIONSET 0x20
#define LCD_SETCGRAMADDR 0x40
#define LCD_SETDDRAMADDR 0x80

// flags for display entry mode
#define LCD_ENTRYRIGHT 0x00
#define LCD_ENTRYLEFT 0x02
#define LCD_ENTRYSHIFTINCREMENT 0x01
#define LCD_ENTRYSHIFTDECREMENT 0x00

// flags for display on/off control
#define LCD_DISPLAYON 0x04
#define LCD_DISPLAYOFF 0x00
#define LCD_CURSORON 0x02
#define LCD_CURSOROFF 0x00
#define LCD_BLINKON 0x01
#define LCD_BLINKOFF 0x00

// flags for display/cursor shift
#define LCD_DISPLAYMOVE 0x08
#define LCD_CURSORMOVE 0x00
#define LCD_MOVERIGHT 0x04
#define LCD_MOVELEFT 0x00

// flags for function set
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE 0x08
#define LCD_1LINE 0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00

// flags for backlight control
#define LCD_BACKLIGHT 0x08
#define LCD_NOBACKLIGHT 0x00

#define En B00000100  // Enable bit
#define Rw B00000010  // Read/Write bit
#define Rs B00000001  // Register select bit

class LiquidCrystal_I2C : public Print {
public:
  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);
  // Example: 	const char bell[8] PROGMEM = {B00100,B01110,B01110,B01110,B11111,B00000,B00100,B00000};
  
  void setCursor(uint8_t, uint8_t); 
#if defined(ARDUINO) && ARDUINO >= 100
  virtual size_t write(uint8_t);
#else
  virtual void write(uint8_t);
#endif
  void command(uint8_t);
  void init();

////compatibility API function aliases
void blink_on();						// alias for blink()
void blink_off();       					// alias for noBlink()
void cursor_on();      	 					// alias for cursor()
void cursor_off();      					// alias for noCursor()
void setBacklight(uint8_t new_val);				// alias for backlight() and nobacklight()
void load_custom_character(uint8_t char_num, uint8_t *rows);	// alias for createChar()
void printstr(const char[]);

////Unsupported API functions (not implemented in this library)
uint8_t status();
void setContrast(uint8_t new_val);
uint8_t keypad();
void setDelay(int,int);
void on();
void off();
uint8_t init_bargraph(uint8_t graphtype);
void draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end);
void draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_col_end);
	 

private:
  void init_priv();
  void send(uint8_t, uint8_t);
  void write4bits(uint8_t);
  void expanderWrite(uint8_t);
  void pulseEnable(uint8_t);
  uint8_t _Addr;
  uint8_t _displayfunction;
  uint8_t _displaycontrol;
  uint8_t _displaymode;
  uint8_t _numlines;
  uint8_t _cols;
  uint8_t _rows;
  uint8_t _backlightval;
};

#endif
