├── .gitattributes ├── Image converter ├── ImageProcessor │ └── download.txt └── BITmaper-outdated.zip ├── icons ├── icons7x7.png ├── icons8x8.png ├── readme.txt └── iconsVisualiser │ └── iconsVisualiser.pde ├── .github ├── CODEOWNERS └── workflows │ ├── tg-send.yml │ └── tests.yml ├── .gitignore ├── library.properties ├── examples ├── menuButton │ └── menuButton.ino ├── drawBattery │ └── drawBattery.ino ├── bitmap_move_fast_nobuf │ └── bitmap_move_fast_nobuf.ino ├── bitmap_move_fast │ └── bitmap_move_fast.ino ├── drawIcons │ └── drawIcons.ino ├── oledPrintTest │ └── oledPrintTest.ino ├── 3Dcube │ └── 3Dcube.ino ├── oled_demo │ └── oled_demo.ino ├── animations │ └── animations.ino └── bitmap_demo │ └── bitmap_demo.ino ├── LICENSE ├── keywords.txt ├── src ├── icons_7x7.h ├── icons_8x8.h ├── charMap.h └── GyverOLED.h ├── README_EN.md └── README.md /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | -------------------------------------------------------------------------------- /Image converter/ImageProcessor/download.txt: -------------------------------------------------------------------------------- 1 | https://github.com/AlexGyver/imageProcessor -------------------------------------------------------------------------------- /icons/icons7x7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GyverLibs/GyverOLED/HEAD/icons/icons7x7.png -------------------------------------------------------------------------------- /icons/icons8x8.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GyverLibs/GyverOLED/HEAD/icons/icons8x8.png -------------------------------------------------------------------------------- /.github/CODEOWNERS: -------------------------------------------------------------------------------- 1 | # docs: 2 | 3 | * @AlexGyver 4 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | ## IDEs 2 | /.vscode 3 | /.idea 4 | 5 | ## Temp files/dirs 6 | /tmp 7 | /temp 8 | /ignore 9 | -------------------------------------------------------------------------------- /Image converter/BITmaper-outdated.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GyverLibs/GyverOLED/HEAD/Image converter/BITmaper-outdated.zip -------------------------------------------------------------------------------- /icons/readme.txt: -------------------------------------------------------------------------------- 1 | В библиотеке есть файлы icons_7x7.h и icons_8x8.h, в них по 150 иконок кодом 2 | Можно вставить в свой код и использовать, смотри пример drawIcons 3 | Как выглядят иконки - смотри в этой папке (где readme) 4 | В папке iconsVisualiser лежит программа на processing, из которой получены картинки иконок -------------------------------------------------------------------------------- /library.properties: -------------------------------------------------------------------------------- 1 | name=GyverOLED 2 | version=1.6.4 3 | author=AlexGyver 4 | maintainer=AlexGyver 5 | sentence=Fast and light library for SSD1306/SSH1106 OLED display 6 | paragraph=Fast and light library for SSD1306/SSH1106 OLED display 7 | category=Display 8 | url=https://github.com/GyverLibs/GyverOLED 9 | architectures=* 10 | -------------------------------------------------------------------------------- /.github/workflows/tg-send.yml: -------------------------------------------------------------------------------- 1 | 2 | name: Telegram Message 3 | on: 4 | release: 5 | types: [published] 6 | jobs: 7 | build: 8 | name: Send Message 9 | runs-on: ubuntu-latest 10 | steps: 11 | - name: send telegram message on push 12 | uses: appleboy/telegram-action@master 13 | with: 14 | to: ${{ secrets.TELEGRAM_TO }} 15 | token: ${{ secrets.TELEGRAM_TOKEN }} 16 | disable_web_page_preview: true 17 | message: | 18 | ${{ github.event.repository.name }} v${{ github.event.release.tag_name }} 19 | ${{ github.event.release.body }} 20 | https://github.com/${{ github.repository }} 21 | -------------------------------------------------------------------------------- /.github/workflows/tests.yml: -------------------------------------------------------------------------------- 1 | name: tests 2 | 3 | on: 4 | push: 5 | branches: [master, main] 6 | paths-ignore: 7 | - '**.md' 8 | tags-ignore: 9 | - '**' 10 | pull_request: 11 | paths-ignore: 12 | - '**.md' 13 | 14 | jobs: # Docs: 15 | lint: 16 | runs-on: ubuntu-20.04 17 | steps: 18 | - name: Check out code 19 | uses: actions/checkout@v2 20 | 21 | # Its focus is on the structure, metadata, and configuration of Arduino projects, rather than the code 22 | - name: Run the linter 23 | uses: arduino/arduino-lint-action@v1 # https://github.com/arduino/arduino-lint-action 24 | with: 25 | project-type: library 26 | library-manager: update 27 | compliance: specification 28 | -------------------------------------------------------------------------------- /examples/menuButton/menuButton.ino: -------------------------------------------------------------------------------- 1 | #include 2 | //GyverOLED oled; 3 | //GyverOLED oled; 4 | //GyverOLED oled; 5 | //GyverOLED oled; 6 | //GyverOLED oled; 7 | GyverOLED oled; 8 | // можно передать адрес: GyverOLED oled(0x3C); 9 | 10 | void setup() { 11 | Serial.begin(9600); 12 | oled.init(); // инициализация 13 | Wire.setClock(400000L); 14 | oled.clear(); 15 | oled.update(); 16 | 17 | byte textPos1 = 8; 18 | byte textPos2 = 32; 19 | 20 | oled.createBuffer(5, 0, 66, textPos2 + 8 + 2); 21 | 22 | oled.roundRect(5, textPos1 - 4, 65, textPos1 + 8 + 2, OLED_STROKE); 23 | oled.setCursorXY(10, textPos1); 24 | oled.print("SET MODE"); 25 | 26 | oled.roundRect(5, textPos2 - 4, 65, textPos2 + 8 + 2, OLED_FILL); 27 | oled.setCursorXY(10, textPos2); 28 | oled.invertText(true); 29 | oled.print("LOL KEK"); 30 | 31 | oled.sendBuffer(); 32 | oled.update(); 33 | } 34 | void loop() { 35 | } 36 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 AlexGyver 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /examples/drawBattery/drawBattery.ino: -------------------------------------------------------------------------------- 1 | #include 2 | //GyverOLED oled; 3 | //GyverOLED oled; 4 | //GyverOLED oled; 5 | //GyverOLED oled; 6 | //GyverOLED oled; 7 | GyverOLED oled; 8 | // можно передать адрес: GyverOLED oled(0x3C); 9 | 10 | void setup() { 11 | oled.init(); // инициализация 12 | oled.clear(); 13 | } 14 | 15 | void loop() { 16 | for (byte i = 0; i < 100; i += 5) { 17 | oled.clear(); 18 | oled.setCursorXY(0, 0); 19 | drawBattery(i); 20 | oled.update(); 21 | delay(50); 22 | } 23 | for (int i = 100; i > 0; i -= 5) { 24 | oled.clear(); 25 | oled.setCursorXY(0, 0); 26 | drawBattery(i); 27 | oled.update(); 28 | delay(50); 29 | } 30 | } 31 | 32 | void drawBattery(byte percent) { 33 | oled.drawByte(0b00111100); // пипка 34 | oled.drawByte(0b00111100); 35 | oled.drawByte(0b11111111); // стенка 36 | for (byte i = 0; i < 100 / 8; i++) { 37 | if (i < (100 - percent) / 8) oled.drawByte(0b10000001); 38 | else oled.drawByte(0b11111111); 39 | } 40 | oled.drawByte(0b11111111); // попка 41 | } 42 | -------------------------------------------------------------------------------- /keywords.txt: -------------------------------------------------------------------------------- 1 | ####################################### 2 | # Syntax Coloring Map For GyverOLED 3 | ####################################### 4 | 5 | ####################################### 6 | # Datatypes (KEYWORD1) 7 | ####################################### 8 | GyverOLED KEYWORD1 9 | OLED_NO_PRINT KEYWORD1 10 | OLED_SPI_SPEED LITERAL1 KEYWORD1 11 | 12 | ####################################### 13 | # Methods and Functions (KEYWORD2) 14 | ####################################### 15 | init KEYWORD2 16 | clear KEYWORD2 17 | setContrast KEYWORD2 18 | flipH KEYWORD2 19 | flipV KEYWORD2 20 | setScale KEYWORD2 21 | invertText KEYWORD2 22 | invertDisplay KEYWORD2 23 | autoPrintln KEYWORD2 24 | textMode KEYWORD2 25 | 26 | home KEYWORD2 27 | setCursor KEYWORD2 28 | setCursorXY KEYWORD2 29 | 30 | dot KEYWORD2 31 | line KEYWORD2 32 | rect KEYWORD2 33 | roundRect KEYWORD2 34 | circle KEYWORD2 35 | fill KEYWORD2 36 | drawByte KEYWORD2 37 | drawBitmap KEYWORD2 38 | 39 | update KEYWORD2 40 | createBuf KEYWORD2 41 | sendBuf KEYWORD2 42 | 43 | ####################################### 44 | # Constants (LITERAL1) 45 | ####################################### 46 | SSD1306_128x32 LITERAL1 47 | SSD1306_128x64 LITERAL1 48 | SSH1106_128x64 LITERAL1 49 | 50 | OLED_BUFFER LITERAL1 51 | OLED_NO_BUFFER LITERAL1 52 | 53 | OLED_STROKE LITERAL1 54 | OLED_FILL LITERAL1 55 | OLED_CLEAR LITERAL1 56 | OLED_INVERT LITERAL1 57 | 58 | BUF_ADD LITERAL1 59 | BUF_SUBTRACT LITERAL1 60 | BUF_REPLACE LITERAL1 61 | 62 | BITMAP_NORMAL LITERAL1 63 | BITMAP_INVERT LITERAL1 64 | 65 | USE_MICRO_WIRE LITERAL1 66 | 67 | OLED_I2C LITERAL1 68 | OLED_SPI LITERAL1 -------------------------------------------------------------------------------- /examples/bitmap_move_fast_nobuf/bitmap_move_fast_nobuf.ino: -------------------------------------------------------------------------------- 1 | // работаем с буфером. Выводим битмап, обновляем только в области изменения 2 | // получаем огромную скорость обновления! 3 | 4 | const uint8_t bitmap_32x32[] PROGMEM = { 5 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xC0, 0xE0, 0xF0, 0x70, 0x70, 0x30, 0x30, 0x30, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF0, 0x70, 0x30, 0x30, 0x20, 0x00, 0x00, 6 | 0x00, 0x30, 0x78, 0xFC, 0x7F, 0x3F, 0x0F, 0x0F, 0x1F, 0x3C, 0x78, 0xF0, 0xE0, 0xC0, 0x80, 0x80, 0x80, 0x40, 0xE0, 0xF0, 0xF8, 0xFC, 0xFF, 0x7F, 0x33, 0x13, 0x1E, 0x1C, 0x1C, 0x0E, 0x07, 0x00, 7 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF9, 0xF7, 0xEF, 0x5F, 0x3F, 0x7F, 0xFE, 0xFD, 0xFB, 0xF1, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 8 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x1E, 0x33, 0x33, 0x1F, 0x0F, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x1F, 0x0E, 0x04, 0x00, 0x00, 0x00, 0x00, 9 | }; 10 | 11 | #include 12 | GyverOLED oled; 13 | // можно передать адрес: GyverOLED oled(0x3C); 14 | 15 | void setup() { 16 | oled.init(); 17 | Wire.setClock(400000L); 18 | } 19 | 20 | int posX = 64, posY = 32; // начальная позиция 21 | int velX = 4, velY = 3; // скорость 22 | void loop() { 23 | // движение с отскоками. Заходим на половину за стенки! Для теста 24 | posX += velX; 25 | posY += velY; 26 | if (posX >= 128 - 16 || posX <= -16) velX = -velX; 27 | if (posY >= 64 - 16 || posY <= -16) velY = -velY; 28 | 29 | // выводим картинку 30 | oled.drawBitmap(posX, posY, bitmap_32x32, 32, 32); 31 | 32 | delay(50); 33 | 34 | // очищаем только область картинки 35 | oled.clear(posX, posY, posX + 32, posY + 32); 36 | } 37 | -------------------------------------------------------------------------------- /examples/bitmap_move_fast/bitmap_move_fast.ino: -------------------------------------------------------------------------------- 1 | // работаем с буфером. Выводим битмап, обновляем только в области изменения 2 | // получаем огромную скорость обновления! 3 | 4 | const uint8_t bitmap_32x32[] PROGMEM = { 5 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xC0, 0xE0, 0xF0, 0x70, 0x70, 0x30, 0x30, 0x30, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF0, 0x70, 0x30, 0x30, 0x20, 0x00, 0x00, 6 | 0x00, 0x30, 0x78, 0xFC, 0x7F, 0x3F, 0x0F, 0x0F, 0x1F, 0x3C, 0x78, 0xF0, 0xE0, 0xC0, 0x80, 0x80, 0x80, 0x40, 0xE0, 0xF0, 0xF8, 0xFC, 0xFF, 0x7F, 0x33, 0x13, 0x1E, 0x1C, 0x1C, 0x0E, 0x07, 0x00, 7 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF9, 0xF7, 0xEF, 0x5F, 0x3F, 0x7F, 0xFE, 0xFD, 0xFB, 0xF1, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 8 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x1E, 0x33, 0x33, 0x1F, 0x0F, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x1F, 0x0E, 0x04, 0x00, 0x00, 0x00, 0x00, 9 | }; 10 | 11 | #include 12 | GyverOLED oled; 13 | // можно передать адрес: GyverOLED oled(0x3C); 14 | 15 | void setup() { 16 | oled.init(); 17 | Wire.setClock(400000L); 18 | } 19 | 20 | int posX = 64, posY = 32; // начальная позиция 21 | int velX = 4, velY = 3; // скорость 22 | void loop() { 23 | // движение с отскоками. Заходим на половину за стенки! Для теста 24 | posX += velX; 25 | posY += velY; 26 | if (posX >= 128 - 16 || posX <= -16) velX = -velX; 27 | if (posY >= 64 - 16 || posY <= -16) velY = -velY; 28 | 29 | // выводим картинку 30 | oled.drawBitmap(posX, posY, bitmap_32x32, 32, 32); 31 | 32 | // обновляем буфер только в области изменения (+-4х и +-3y от рисования) 33 | oled.update(posX - 4, posY - 3, posX + 32 + 4, posY + 32 + 3); 34 | 35 | // очищаем буфер 36 | oled.clear(posX, posY, posX + 32, posY + 32); 37 | } 38 | -------------------------------------------------------------------------------- /examples/drawIcons/drawIcons.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | GyverOLED oled; 4 | 5 | const static uint8_t icons_7x7[][7] PROGMEM = { 6 | {0x7f, 0x45, 0x49, 0x51, 0x49, 0x45, 0x7f}, //0 email 7 | {0x40, 0x60, 0x77, 0x77, 0x77, 0x60, 0x40}, //1 user 8 | {0x70, 0x7e, 0x71, 0x51, 0x71, 0x7e, 0x70}, //2 lock, password 9 | }; 10 | 11 | const static uint8_t icons_8x8[][8] PROGMEM = { 12 | {0x7e, 0x81, 0x81, 0x91, 0x88, 0x85, 0x83, 0x77}, //0 maximize 13 | {0x7c, 0x44, 0xe7, 0xa5, 0xa5, 0xe7, 0x44, 0x7c}, //1 printer 14 | {0x7e, 0x81, 0x91, 0xa1, 0x91, 0x89, 0x84, 0x72}, //2 checked 15 | {0x7e, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x7e}, //3 unchecked 16 | {0x1c, 0x3e, 0x73, 0xe1, 0xe1, 0x73, 0x3e, 0x1c}, //4 map 17 | }; 18 | 19 | void setup() { 20 | 21 | oled.init(); // инициализация 22 | 23 | // ускорим вывод, ВЫЗЫВАТЬ ПОСЛЕ oled.init()!!! 24 | Wire.setClock(400000L); // макс. 800'000 25 | 26 | oled.clear(); 27 | oled.home(); 28 | 29 | drawIcon7x7(0); 30 | oled.setCursor(1 << 3, 0); 31 | drawIcon7x7(1); 32 | oled.setCursor(2 << 3, 0); 33 | drawIcon7x7(2); 34 | 35 | oled.setCursor(0 << 3, 2); 36 | drawIcon8x8(0); 37 | oled.setCursor(2 << 3, 2); 38 | drawIcon8x8(1); 39 | oled.setCursor(4 << 3, 2); 40 | drawIcon8x8(2); 41 | oled.setCursor(6 << 3, 2); 42 | drawIcon8x8(3); 43 | oled.setCursor(8 << 3, 2); 44 | drawIcon8x8(4); 45 | } 46 | 47 | void loop() { 48 | } 49 | 50 | 51 | void drawIcon7x7(byte index) { 52 | size_t s = sizeof icons_7x7[index];//можно так, а можно просто 7 53 | for(unsigned int i = 0; i < s; i++) { 54 | oled.drawByte(pgm_read_byte(&(icons_7x7[index][i]))); 55 | } 56 | } 57 | 58 | void drawIcon8x8(byte index) { 59 | size_t s = sizeof icons_8x8[index];//можна так, а можна просто 8 60 | for(unsigned int i = 0; i < s; i++) { 61 | oled.drawByte(pgm_read_byte(&(icons_8x8[index][i]))); 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /examples/oledPrintTest/oledPrintTest.ino: -------------------------------------------------------------------------------- 1 | #include 2 | //GyverOLED oled; 3 | //GyverOLED oled; 4 | //GyverOLED oled; 5 | //GyverOLED oled; 6 | //GyverOLED oled; 7 | GyverOLED oled; 8 | 9 | char Lorem_ipsum[] = "Lorem ipsum dolor sit amet, лорем ипсум долор сит амет привет народ ё, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip..."; 10 | void setup() { 11 | Serial.begin(9600); 12 | oled.init(); // инициализация 13 | } 14 | 15 | void loop() { 16 | printScale(1); 17 | printScale(2); 18 | printScale(3); 19 | printScale(4); 20 | overlapTest(); 21 | printTest(); 22 | party(); 23 | showText(); 24 | scrollText(); 25 | scaleText(); 26 | } 27 | 28 | void printScale(byte x) { 29 | oled.clear(); 30 | oled.setScale(x); 31 | for (byte i = 0; i < 8; i += x) { 32 | oled.setCursor(0, i); 33 | oled.print("Hello!"); 34 | } 35 | oled.update(); 36 | delay(1000); 37 | } 38 | 39 | void party() { 40 | oled.clear(); 41 | uint32_t tmr = millis(); 42 | oled.setScale(3); 43 | oled.setCursor(10, 2); 44 | oled.print("ПЕННАЯ"); 45 | oled.setScale(2); 46 | oled.setCursor(6, 5); 47 | oled.print("ВЕЧЕРИНКА!"); 48 | oled.update(); 49 | for (;;) { 50 | oled.invertDisplay(true); 51 | delay(200); 52 | oled.invertDisplay(false); 53 | delay(200); 54 | if (millis() - tmr > 5000) return; 55 | } 56 | } 57 | 58 | void overlapTest() { 59 | oled.clear(); 60 | oled.setScale(1); 61 | oled.setCursorXY(0, 0); 62 | oled.print("LOL"); 63 | oled.update(); 64 | delay(500); 65 | oled.setCursorXY(0, 8); 66 | oled.print("KEK!"); 67 | oled.update(); 68 | delay(500); 69 | 70 | oled.setCursorXY(40, 4); 71 | oled.print("LOL"); 72 | oled.update(); 73 | delay(500); 74 | oled.setCursorXY(40, 12); 75 | oled.print("KEK!"); 76 | oled.update(); 77 | delay(500); 78 | 79 | oled.setScale(2); 80 | oled.setCursorXY(0, 24); 81 | oled.print("LOL"); 82 | oled.update(); 83 | delay(500); 84 | oled.setCursorXY(0, 40); 85 | oled.print("KEK!"); 86 | oled.update(); 87 | delay(500); 88 | 89 | oled.setCursorXY(60, 28); 90 | oled.print("LOL"); 91 | oled.update(); 92 | delay(500); 93 | oled.setCursorXY(60, 44); 94 | oled.print("KEK!"); 95 | oled.update(); 96 | delay(5000); 97 | } 98 | 99 | void printTest() { 100 | oled.clear(); 101 | char data0[] = "Привет!"; 102 | char data1 = 'b'; 103 | int data2 = -50; 104 | float data3 = 1.25; 105 | oled.home(); 106 | oled.setScale(1); 107 | oled.println(data0); 108 | oled.println(data1); 109 | oled.invertText(true); 110 | oled.println(data2); 111 | oled.println(data3); 112 | oled.invertText(false); 113 | oled.update(); 114 | delay(5000); 115 | } 116 | 117 | void showText() { 118 | oled.clear(); 119 | oled.home(); 120 | oled.autoPrintln(true); 121 | oled.setScale(1); 122 | oled.print(Lorem_ipsum); 123 | oled.update(); 124 | delay(5000); 125 | } 126 | 127 | void scrollText() { 128 | oled.clear(); 129 | uint32_t tmr = millis(); 130 | oled.autoPrintln(false); 131 | int val = 128; 132 | for (;;) { 133 | oled.clear(); // ЗАКОММЕНТИРУЙ, ЕСЛИ ВКЛЮЧЕН БУФЕР 134 | oled.setScale(1); 135 | oled.setCursor(val, 0); 136 | oled.print(Lorem_ipsum); 137 | 138 | oled.setScale(2); 139 | oled.setCursor(val, 1); 140 | oled.print(Lorem_ipsum); 141 | 142 | oled.setScale(3); 143 | oled.setCursor(val, 4); 144 | oled.print(Lorem_ipsum); 145 | oled.update(); 146 | val--; 147 | if (millis() - tmr > 5000) return; 148 | } 149 | } 150 | 151 | void scaleText() { 152 | uint32_t tmr = millis(); 153 | byte scale = 1; 154 | oled.autoPrintln(true); 155 | for (;;) { 156 | oled.clear(); 157 | oled.setScale(scale); 158 | oled.home(); 159 | oled.print("Привет!"); 160 | oled.update(); 161 | delay(1000); 162 | oled.clear(); 163 | scale++; 164 | if (scale > 4) scale = 1; 165 | if (millis() - tmr > 5000) return; 166 | } 167 | } 168 | -------------------------------------------------------------------------------- /examples/3Dcube/3Dcube.ino: -------------------------------------------------------------------------------- 1 | // Пример GyverOLED. Смотри документацию на http://alexgyver.ru/gyveroled/ 2 | // классический пример с 3D кубом 3 | #define RES 8 4 | #define DC 7 5 | #define CS 6 6 | 7 | #define OLED_SPI_SPEED 8000000ul 8 | #include 9 | //GyverOLED oled; 10 | //GyverOLED oled; 11 | //GyverOLED oled; 12 | //GyverOLED oled; 13 | //GyverOLED oled; 14 | GyverOLED oled; 15 | 16 | 17 | double vectors[8][3] = {{20, 20, 20}, { -20, 20, 20}, { -20, -20, 20}, {20, -20, 20}, {20, 20, -20}, { -20, 20, -20}, { -20, -20, -20}, {20, -20, -20}}; 18 | double perspective = 100.0f; 19 | int deltaX, deltaY, deltaZ, iter = 0; 20 | uint32_t timer; 21 | 22 | void setup() { 23 | oled.init(); 24 | Wire.setClock(800000L); 25 | timer = millis(); 26 | } 27 | 28 | void loop() { 29 | oled.clear(); 30 | oled.home(); 31 | oled.print(1000 / timer); 32 | 33 | timer = millis(); 34 | drawVectors(); 35 | if (iter == 0) { 36 | deltaX = random(7) - 3; 37 | deltaY = random(7) - 3; 38 | deltaZ = random(7) - 3; 39 | iter = random(250) + 5; 40 | } 41 | rotateX(deltaX); 42 | rotateY(deltaY); 43 | rotateZ(deltaZ); 44 | iter--; 45 | oled.update(); 46 | timer = millis() - timer; 47 | } 48 | 49 | int translateX(double x, double z) { 50 | return (int)((x + 64) + (z * (x / perspective))); 51 | } 52 | 53 | int translateY(double y, double z) { 54 | return (int)((y + 32) + (z * (y / perspective))); 55 | } 56 | 57 | void rotateX(int angle) { 58 | double rad, cosa, sina, Yn, Zn; 59 | rad = angle * PI / 180; 60 | cosa = cos(rad); 61 | sina = sin(rad); 62 | for (int i = 0; i < 8; i++) { 63 | Yn = (vectors[i][1] * cosa) - (vectors[i][2] * sina); 64 | Zn = (vectors[i][1] * sina) + (vectors[i][2] * cosa); 65 | vectors[i][1] = Yn; 66 | vectors[i][2] = Zn; 67 | } 68 | } 69 | 70 | void rotateY(int angle) { 71 | double rad, cosa, sina, Xn, Zn; 72 | rad = angle * PI / 180; 73 | cosa = cos(rad); 74 | sina = sin(rad); 75 | for (int i = 0; i < 8; i++) 76 | { 77 | Xn = (vectors[i][0] * cosa) - (vectors[i][2] * sina); 78 | Zn = (vectors[i][0] * sina) + (vectors[i][2] * cosa); 79 | vectors[i][0] = Xn; 80 | vectors[i][2] = Zn; 81 | } 82 | } 83 | 84 | void rotateZ(int angle) { 85 | double rad, cosa, sina, Xn, Yn; 86 | rad = angle * PI / 180; 87 | cosa = cos(rad); 88 | sina = sin(rad); 89 | for (int i = 0; i < 8; i++) { 90 | Xn = (vectors[i][0] * cosa) - (vectors[i][1] * sina); 91 | Yn = (vectors[i][0] * sina) + (vectors[i][1] * cosa); 92 | vectors[i][0] = Xn; 93 | vectors[i][1] = Yn; 94 | } 95 | } 96 | 97 | void drawVectors() { 98 | oled.line(translateX(vectors[0][0], vectors[0][2]), translateY(vectors[0][1], vectors[0][2]), translateX(vectors[1][0], vectors[1][2]), translateY(vectors[1][1], vectors[1][2])); 99 | oled.line(translateX(vectors[1][0], vectors[1][2]), translateY(vectors[1][1], vectors[1][2]), translateX(vectors[2][0], vectors[2][2]), translateY(vectors[2][1], vectors[2][2])); 100 | oled.line(translateX(vectors[2][0], vectors[2][2]), translateY(vectors[2][1], vectors[2][2]), translateX(vectors[3][0], vectors[3][2]), translateY(vectors[3][1], vectors[3][2])); 101 | oled.line(translateX(vectors[3][0], vectors[3][2]), translateY(vectors[3][1], vectors[3][2]), translateX(vectors[0][0], vectors[0][2]), translateY(vectors[0][1], vectors[0][2])); 102 | oled.line(translateX(vectors[4][0], vectors[4][2]), translateY(vectors[4][1], vectors[4][2]), translateX(vectors[5][0], vectors[5][2]), translateY(vectors[5][1], vectors[5][2])); 103 | oled.line(translateX(vectors[5][0], vectors[5][2]), translateY(vectors[5][1], vectors[5][2]), translateX(vectors[6][0], vectors[6][2]), translateY(vectors[6][1], vectors[6][2])); 104 | oled.line(translateX(vectors[6][0], vectors[6][2]), translateY(vectors[6][1], vectors[6][2]), translateX(vectors[7][0], vectors[7][2]), translateY(vectors[7][1], vectors[7][2])); 105 | oled.line(translateX(vectors[7][0], vectors[7][2]), translateY(vectors[7][1], vectors[7][2]), translateX(vectors[4][0], vectors[4][2]), translateY(vectors[4][1], vectors[4][2])); 106 | oled.line(translateX(vectors[0][0], vectors[0][2]), translateY(vectors[0][1], vectors[0][2]), translateX(vectors[4][0], vectors[4][2]), translateY(vectors[4][1], vectors[4][2])); 107 | oled.line(translateX(vectors[1][0], vectors[1][2]), translateY(vectors[1][1], vectors[1][2]), translateX(vectors[5][0], vectors[5][2]), translateY(vectors[5][1], vectors[5][2])); 108 | oled.line(translateX(vectors[2][0], vectors[2][2]), translateY(vectors[2][1], vectors[2][2]), translateX(vectors[6][0], vectors[6][2]), translateY(vectors[6][1], vectors[6][2])); 109 | oled.line(translateX(vectors[3][0], vectors[3][2]), translateY(vectors[3][1], vectors[3][2]), translateX(vectors[7][0], vectors[7][2]), translateY(vectors[7][1], vectors[7][2])); 110 | } 111 | -------------------------------------------------------------------------------- /examples/oled_demo/oled_demo.ino: -------------------------------------------------------------------------------- 1 | // дефайн перед подключением либы - использовать microWire (лёгкая либа для I2C) 2 | //#define USE_MICRO_WIRE 3 | 4 | // дефайн перед подключением либы - скорость SPI 5 | //#define OLED_SPI_SPEED 4000000ul 6 | 7 | #include 8 | 9 | // инициализация: 10 | // GyverOLED<модель, буфер, интерфейс, CS, DC, RST> oled; 11 | // "по умолчанию" - можно не указывать 12 | 13 | // модель дисплея: 14 | // SSD1306_128x32 15 | // SSD1306_128x64 16 | // SSH1106_128x64 (ТОЛЬКО С БУФЕРОМ) 17 | 18 | // буфер: 19 | // OLED_NO_BUFFER (без буфера) 20 | // OLED_BUFFER (с буфером на стороне МК) - по умолчанию 21 | 22 | // интерфейс: 23 | // OLED_I2C - по умолчанию 24 | // OLED_SPI (указать пины CS, DC, RST/RES) 25 | 26 | // примеры: 27 | //GyverOLED oled; 28 | //GyverOLED oled; 29 | //GyverOLED oled; 30 | //GyverOLED oled; 31 | //GyverOLED oled; 32 | GyverOLED oled; 33 | 34 | // для I2C можно передать адрес: GyverOLED oled(0x3C); 35 | 36 | // битмап создан в ImageProcessor https://github.com/AlexGyver/imageProcessor 37 | // с параметрами вывода vertical byte (OLED) 38 | const uint8_t bitmap_32x32[] PROGMEM = { 39 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xC0, 0xE0, 0xF0, 0x70, 0x70, 0x30, 0x30, 0x30, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF0, 0x70, 0x30, 0x30, 0x20, 0x00, 0x00, 40 | 0x00, 0x30, 0x78, 0xFC, 0x7F, 0x3F, 0x0F, 0x0F, 0x1F, 0x3C, 0x78, 0xF0, 0xE0, 0xC0, 0x80, 0x80, 0x80, 0x40, 0xE0, 0xF0, 0xF8, 0xFC, 0xFF, 0x7F, 0x33, 0x13, 0x1E, 0x1C, 0x1C, 0x0E, 0x07, 0x00, 41 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF9, 0xF7, 0xEF, 0x5F, 0x3F, 0x7F, 0xFE, 0xFD, 0xFB, 0xF1, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 42 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x1E, 0x33, 0x33, 0x1F, 0x0F, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x1F, 0x0E, 0x04, 0x00, 0x00, 0x00, 0x00, 43 | }; 44 | 45 | void setup() { 46 | Serial.begin(9600); 47 | oled.init(); // инициализация 48 | 49 | // -------------------------- 50 | // настройка скорости I2C 51 | //Wire.setClock(800000L); // макс. 800'000 52 | 53 | // -------------------------- 54 | oled.clear(); // очистить дисплей (или буфер) 55 | oled.update(); // обновить. Только для режима с буфером! OLED_BUFFER 56 | 57 | // -------------------------- 58 | oled.home(); // курсор в 0,0 59 | oled.print("Hello!"); // печатай что угодно: числа, строки, float, как Serial! 60 | oled.update(); 61 | delay(2000); 62 | 63 | // -------------------------- 64 | oled.setCursor(5, 1); // курсор в (пиксель X, строка Y) 65 | oled.setScale(2); 66 | oled.print("Hello!"); 67 | oled.update(); 68 | delay(2000); 69 | 70 | // -------------------------- 71 | oled.setCursorXY(15, 30); // курсор в (пиксель X, пиксель Y) 72 | oled.setScale(3); 73 | oled.invertText(true); // инвертируй текст! 74 | oled.print("Привет!"); 75 | oled.update(); 76 | delay(2000); 77 | 78 | // -------------------------- 79 | oled.clear(); 80 | oled.home(); 81 | oled.setScale(1); 82 | oled.invertText(false); 83 | oled.autoPrintln(true); // автоматически переносить текст 84 | oled.print(F("Lorem ipsum dolor sit amet, лорем ипсум долор сит амет привет народ ё, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam")); 85 | oled.update(); 86 | delay(2000); 87 | 88 | // -------------------------- 89 | oled.home(); 90 | oled.textMode(BUF_ADD); 91 | // BUF_ADD - наложить текст 92 | // BUF_SUBTRACT - вычесть текст 93 | // BUF_REPLACE - заменить (весь прямоугольник буквы) 94 | oled.home(); 95 | oled.setScale(3); 96 | oled.print("KEK!"); 97 | oled.update(); 98 | delay(2000); 99 | 100 | // -------------------------- 101 | // СЕРВИС 102 | //oled.setContrast(10); // яркость 0..255 103 | //oled.setPower(true); // true/false - включить/выключить дисплей 104 | //oled.flipH(true); // true/false - отзеркалить по горизонтали 105 | //oled.flipV(true); // true/false - отзеркалить по вертикали 106 | //oled.isEnd(); // возвращает true, если дисплей "кончился" - при побуквенном выводе 107 | 108 | // -------------------------- 109 | oled.clear(); 110 | oled.dot(0, 0); // точка на x,y 111 | oled.dot(0, 1, 1); // третий аргумент: 0 выкл пиксель, 1 вкл пиксель (по умолч) 112 | oled.line(5, 5, 10, 10); // линия x0,y0,x1,y1 113 | //oled.line(5, 5, 10, 10, 0); // пятый аргумент: 0 стереть, 1 нарисовать (по умолч) 114 | oled.fastLineH(0, 5, 10); // горизонтальная линия (y, x1, x2) 115 | //oled.fastLineH(0, 5, 10, 0); // четвёртый аргумент: 0 стереть, 1 нарисовать (по умолч) 116 | oled.fastLineV(0, 5, 10); // аналогично верт. линия (x, y1, y2) 117 | oled.rect(20, 20, 30, 25); // прямоугольник (x0,y0,x1,y1) 118 | oled.rect(5, 35, 35, 60, OLED_STROKE); // прямоугольник (x0,y0,x1,y1) 119 | // параметры фигуры: 120 | // OLED_CLEAR - очистить 121 | // OLED_FILL - залить 122 | // OLED_STROKE - нарисовать рамку 123 | oled.roundRect(50, 5, 80, 25, OLED_STROKE); // аналогично скруглённый прямоугольник 124 | oled.circle(60, 45, 15, OLED_STROKE); // окружность с центром в (x,y, с радиусом) 125 | oled.circle(60, 45, 5, OLED_FILL); // четвёртый аргумент: параметр фигуры 126 | 127 | // битмап 128 | oled.drawBitmap(90, 16, bitmap_32x32, 32, 32, BITMAP_NORMAL, BUF_ADD); 129 | //oled.drawBitmap(90, 16, bitmap_32x32, 32, 32); // по умолч. нормал и BUF_ADD 130 | // x, y, имя, ширина, высота, BITMAP_NORMAL(0)/BITMAP_INVERT(1), BUF_ADD/BUF_SUBTRACT/BUF_REPLACE 131 | 132 | oled.update(); 133 | } 134 | 135 | void loop() { 136 | } 137 | -------------------------------------------------------------------------------- /examples/animations/animations.ino: -------------------------------------------------------------------------------- 1 | // всякие анимации 2 | //#define OLED_SPI_SPEED 4000000ul 3 | #include 4 | 5 | //GyverOLED oled; 6 | //GyverOLED oled; 7 | GyverOLED oled; 8 | //GyverOLED oled; 9 | //GyverOLED oled; 10 | //GyverOLED oled; 11 | // можно передать адрес: GyverOLED oled(0x3C); 12 | 13 | void setup() { 14 | Serial.begin(9600); 15 | oled.init(); 16 | Wire.setClock(800000L); // макс. 800'000 17 | } 18 | 19 | void loop() { 20 | uint32_t tmr; 21 | 22 | tmr = millis(); 23 | while (millis() - tmr < 5000) net(); 24 | 25 | tmr = millis(); 26 | while (millis() - tmr < 5000) bigBall(); 27 | 28 | tmr = millis(); 29 | while (millis() - tmr < 5000) lines(); 30 | 31 | tmr = millis(); 32 | while (millis() - tmr < 5000) circleModes(); 33 | 34 | tmr = millis(); 35 | while (millis() - tmr < 5000) ball(); 36 | 37 | tmr = millis(); 38 | while (millis() - tmr < 5000) bezier(); 39 | 40 | tmr = millis(); 41 | while (millis() - tmr < 5000) bezier2(); 42 | } 43 | 44 | void bezier2() { 45 | const byte amount = 3; 46 | static bool start = false; 47 | static int x[amount], y[amount]; 48 | static int velX[amount], velY[amount]; 49 | if (!start) { 50 | start = 1; 51 | for (byte i = 0; i < amount; i++) { 52 | x[i] = random(10, (128 - 1) * 10); 53 | y[i] = random(10, (64 - 1) * 10); 54 | velX[i] = random(5, 20); 55 | velY[i] = random(5, 20); 56 | } 57 | } 58 | oled.clear(); 59 | int bez[(amount + 1) * 2]; 60 | for (byte i = 0; i < amount; i++) { 61 | x[i] += velX[i]; 62 | y[i] += velY[i]; 63 | if (x[i] >= (128 - 1) * 10 || x[i] < 0) velX[i] = -velX[i]; 64 | if (y[i] >= (64 - 1) * 10 || y[i] < 0) velY[i] = -velY[i]; 65 | oled.dot(x[i] / 10, y[i] / 10, 1); 66 | bez[i * 2] = x[i] / 10; 67 | bez[i * 2 + 1] = y[i] / 10; 68 | } 69 | bez[amount * 2] = bez[0]; 70 | bez[amount * 2 + 1] = bez[1]; 71 | 72 | oled.bezier(bez, amount + 1, 8); 73 | oled.update(); 74 | } 75 | 76 | void bezier() { 77 | int data[] = {0, 0, 128 / 2, 64 / 2, 0, 64 - 1}; 78 | for (int i = 0; i < 128; i++) { 79 | oled.clear(); 80 | data[0] = data[4] = 128 - i; 81 | data[2] = i; 82 | oled.bezier(data, 3, 7); 83 | oled.update(); 84 | } 85 | for (int i = 128; i > 0; i--) { 86 | oled.clear(); 87 | data[0] = data[4] = 128 - i; 88 | data[2] = i; 89 | oled.bezier(data, 3, 7); 90 | oled.update(); 91 | } 92 | } 93 | 94 | void ball() { 95 | oled.clear(); 96 | static int x, y; 97 | static int velX = 5, velY = 8; 98 | x += velX; 99 | y += velY; 100 | if (x >= (128 - 1) * 10 || x < 0) velX = -velX; 101 | if (y >= (64 - 1) * 10 || y < 0) velY = -velY; 102 | 103 | oled.dot(x / 10, y / 10, 1); 104 | oled.dot(x / 10 + 1, y / 10 + 1, 1); 105 | oled.dot(x / 10 + 1, y / 10, 1); 106 | oled.dot(x / 10, y / 10 + 1, 1); 107 | oled.update(); 108 | delay(10); 109 | } 110 | 111 | void net() { 112 | const byte radius = 3; 113 | const byte amount = 6; 114 | static bool start = false; 115 | static int x[amount], y[amount]; 116 | static int velX[amount], velY[amount]; 117 | if (!start) { 118 | start = 1; 119 | for (byte i = 0; i < amount; i++) { 120 | x[i] = random(10, (128 - 1) * 10); 121 | y[i] = random(10, (64 - 1) * 10); 122 | velX[i] = random(2, 9); 123 | velY[i] = random(2, 9); 124 | } 125 | } 126 | oled.clear(); 127 | for (byte i = 0; i < amount; i++) { 128 | x[i] += velX[i]; 129 | y[i] += velY[i]; 130 | if (x[i] >= (128 - 1 - radius) * 10 || x[i] < radius * 10) velX[i] = -velX[i]; 131 | if (y[i] >= (64 - 1 - radius) * 10 || y[i] < radius * 10) velY[i] = -velY[i]; 132 | oled.circle(x[i] / 10, y[i] / 10, radius); 133 | } 134 | 135 | for (int i = 0; i < amount; i++) { 136 | for (int j = 0; j < amount; j++) { 137 | if (i != j && dist(x[i] / 10, y[i] / 10, x[j] / 10, y[j] / 10) < 35) oled.line(x[i] / 10, y[i] / 10, x[j] / 10, y[j] / 10); 138 | } 139 | } 140 | oled.update(); 141 | } 142 | 143 | int dist(int x1, int y1, int x2, int y2) { 144 | int lx = (x2 - x1); 145 | int ly = (y2 - y1); 146 | return (sqrt(lx * lx + ly * ly)); 147 | } 148 | 149 | void bigBall() { 150 | oled.clear(); 151 | byte radius = 10; 152 | static int x = (128 / 2) * 10, y = (64 / 2) * 10; 153 | static int velX = 17, velY = 9; 154 | static bool fillFlag = 0; 155 | x += velX; 156 | y += velY; 157 | if (x >= (128 - radius) * 10 || x < radius * 10) { 158 | velX = -velX; 159 | fillFlag = !fillFlag; 160 | } 161 | if (y >= (64 - radius) * 10 || y < radius * 10) { 162 | velY = -velY; 163 | fillFlag = !fillFlag; 164 | } 165 | 166 | oled.circle(x / 10, y / 10, radius, fillFlag ? OLED_STROKE : OLED_FILL); 167 | oled.update(); 168 | } 169 | 170 | void lines() { 171 | oled.clear(); 172 | for (byte i = 0; i < 128 - 1; i += 3) { 173 | oled.line(0, 0, i, 64); 174 | oled.update(); 175 | } 176 | for (int i = 64 - 1; i >= 0 ; i -= 3) { 177 | oled.line(0, 0, 128, i); 178 | oled.update(); 179 | } 180 | delay(100); 181 | 182 | oled.clear(); 183 | for (int i = 128 - 1; i > 0; i -= 3) { 184 | oled.line(128 - 1, 0, i, 64); 185 | oled.update(); 186 | } 187 | for (int i = 64 - 1; i > 0; i -= 3) { 188 | oled.line(128 - 1, 0, 0, i); 189 | oled.update(); 190 | } 191 | delay(100); 192 | } 193 | 194 | void circleModes() { 195 | oled.clear(); 196 | oled.fill(255); 197 | oled.createBuffer(64 - 20, 32 - 20, 64 + 20, 32 + 20, 255); 198 | oled.circle(64, 32, 20, OLED_CLEAR); 199 | oled.sendBuffer(); 200 | oled.update(); 201 | delay(800); 202 | 203 | oled.clear(); 204 | oled.createBuffer(64 - 20, 32 - 20, 64 + 20, 32 + 20); 205 | oled.circle(64, 32, 20, OLED_FILL); 206 | oled.sendBuffer(); 207 | oled.update(); 208 | delay(800); 209 | 210 | oled.clear(); 211 | oled.createBuffer(64 - 20, 32 - 20, 64 + 20, 32 + 20); 212 | oled.circle(64, 32, 20, OLED_STROKE); 213 | oled.sendBuffer(); 214 | oled.update(); 215 | delay(800); 216 | } 217 | -------------------------------------------------------------------------------- /examples/bitmap_demo/bitmap_demo.ino: -------------------------------------------------------------------------------- 1 | // Пример GyverOLED. Смотри документацию на http://alexgyver.ru/gyveroled/ 2 | // вывод картинки из памяти, буфер не используем 3 | 4 | // битмап из программы BITmaper OLED (ищи в папке с библиотекой) 5 | const uint8_t bitmap_128x64[] PROGMEM = { 6 | 0xFE, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x04, 0xFC, 0x04, 0xFC, 0x04, 0xFC, 0x04, 0xFC, 0xFC, 0x04, 0xFC, 0x04, 0xFC, 0x04, 0xFC, 0x04, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0x7C, 0x00, 0x1C, 0x80, 0xEC, 0x60, 0x2C, 0x20, 0x2C, 0x40, 0x4C, 0x40, 0x5C, 0x80, 0x9C, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x7C, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0xFC, 0x04, 0xFC, 0x14, 0x7C, 0xE0, 0x00, 0x1C, 0x1C, 0xEC, 0x84, 0xFC, 0x04, 0xFC, 0x84, 0x7C, 0x64, 0x1C, 0x10, 0x8C, 0xC8, 0x64, 0xC4, 7 | 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x40, 0xFF, 0x20, 0x3F, 0x3F, 0x20, 0x3F, 0x20, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x7F, 0x00, 0x7F, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x0F, 0xF0, 0xC0, 0x00, 0x7F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x40, 0x40, 0x80, 0x80, 0x80, 0x00, 0x40, 0x41, 0x40, 0x81, 0x88, 0x8B, 0x08, 0x1B, 0x10, 0x17, 0x30, 0x2F, 0x20, 0x2F, 0x10, 0x1F, 0x00, 0x0F, 0x10, 0x1F, 0x00, 0x00, 0x3F, 0x1F, 0x0C, 0x00, 0x81, 0x81, 0x1F, 0x66, 0x71, 0xD9, 0x8E, 0x07, 0x03, 0x87, 0xCD, 0x78, 0x78, 0xCC, 8 | 0xFF, 0x00, 0xFF, 0x00, 0x3F, 0x00, 0x0F, 0x00, 0x07, 0x30, 0x73, 0xD0, 0xD3, 0x18, 0x09, 0x08, 0x01, 0x00, 0x03, 0x00, 0x03, 0x00, 0x07, 0x00, 0x0F, 0x08, 0x0F, 0x00, 0x1F, 0x00, 0xE3, 0xFC, 0xFF, 0xFF, 0xFC, 0xFE, 0xFE, 0xF9, 0xF8, 0xF2, 0xF8, 0xF9, 0xFC, 0xFC, 0xFF, 0xFE, 0xE6, 0xE2, 0xF0, 0xBD, 0x50, 0x0F, 0x00, 0xBF, 0xE0, 0x4F, 0xE0, 0xF7, 0xF0, 0x7B, 0xBC, 0xDE, 0x6B, 0x81, 0x80, 0x80, 0xC0, 0xF8, 0x8C, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x09, 0x00, 0xFE, 0x00, 0xF8, 0x00, 0xF1, 0x01, 0xF3, 0x02, 0xF2, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0xE0, 0x00, 0xC0, 0x00, 0xC0, 0x10, 0xF0, 0x30, 0xB0, 0x78, 0xC8, 0xE9, 0x61, 0xF0, 0xE8, 0x18, 0xFC, 0xC7, 0x83, 0x03, 0x87, 0xCC, 0x7C, 0x78, 0x6C, 9 | 0x03, 0x80, 0x00, 0x00, 0x30, 0xF8, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xC7, 0xE7, 0x74, 0x7C, 0xF8, 0xF0, 0xF0, 0xF0, 0xE0, 0xE0, 0xC0, 0x80, 0x00, 0x10, 0x30, 0xE0, 0xE6, 0x67, 0x7F, 0x79, 0x71, 0xEF, 0xFF, 0xFF, 0x7F, 0x7F, 0x3F, 0x3F, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x6F, 0xF7, 0xF8, 0xFD, 0xFE, 0xFF, 0xFF, 0xFC, 0xF9, 0xF2, 0xFA, 0xFC, 0xE1, 0xC3, 0xE7, 0x9C, 0xD9, 0xC0, 0x9E, 0x3E, 0x7E, 0x7E, 0xFE, 0xFD, 0xFD, 0xFD, 0xFD, 0x9D, 0xD2, 0xEA, 0x3A, 0x04, 0xC8, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x03, 0xFC, 0x0F, 0xF3, 0x13, 0xE6, 0x2C, 0xC8, 0x0C, 10 | 0xFF, 0x01, 0xE6, 0x18, 0x20, 0xE7, 0x7F, 0x59, 0x60, 0x70, 0xF8, 0xFC, 0x3E, 0x7F, 0xFF, 0x0C, 0x0C, 0x4F, 0x4F, 0x4F, 0x7F, 0x7F, 0xC9, 0x6B, 0x37, 0x1F, 0x0E, 0x00, 0x86, 0x87, 0x80, 0x80, 0xC0, 0xC0, 0xC1, 0x41, 0x00, 0x00, 0x88, 0xCC, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0xFE, 0xFE, 0x7C, 0x3D, 0xC3, 0x07, 0xFF, 0xFF, 0xFF, 0xF3, 0xF7, 0xEF, 0xED, 0xEC, 0xFD, 0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0x3C, 0x01, 0x03, 0x03, 0x03, 0x0E, 0x0D, 0x03, 0x7C, 0x00, 0x7F, 0x00, 0x7F, 0x00, 0x7F, 0x00, 0x7F, 0x00, 0x7F, 0x00, 0xFF, 0x00, 0x7F, 0x80, 0x1F, 0x00, 0x1F, 0x00, 0x9F, 0xC0, 0x3F, 0x40, 0x7F, 0x00, 0x7F, 0x00, 0x7F, 0x00, 0x7F, 0x40, 0x7F, 0x40, 0x7F, 0x40, 0x7F, 0x7F, 0x40, 0x7F, 0x40, 0xFF, 0x80, 0xFF, 0x80, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 11 | 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFC, 0x06, 0xE6, 0x0C, 0xCC, 0x19, 0x98, 0x10, 0x91, 0x01, 0xC0, 0x04, 0xC4, 0x04, 0x84, 0x04, 0xC4, 0x04, 0xEC, 0x09, 0x89, 0x09, 0x89, 0x89, 0x89, 0x09, 0xE0, 0xE0, 0xE0, 0xF4, 0xFE, 0xFF, 0xFF, 0xFD, 0xFB, 0xFB, 0xF7, 0xCF, 0xCF, 0xCF, 0xCF, 0xCC, 0x8C, 0xB4, 0xA7, 0x67, 0x94, 0x33, 0x33, 0xCB, 0x17, 0xAF, 0xDF, 0x3F, 0xFF, 0xFF, 0x3F, 0xCF, 0xE7, 0xF3, 0xFB, 0xF9, 0xFD, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0x84, 0x78, 0xFF, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x0E, 0x0F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0E, 0x0E, 0x06, 0x06, 0x04, 0x85, 0x06, 0x06, 0x06, 12 | 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x7F, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x80, 0x9F, 0xC2, 0x3F, 0x24, 0xF7, 0x99, 0x99, 0x99, 0xE9, 0xC9, 0xD9, 0xE9, 0xE9, 0xF1, 0xF1, 0xFB, 0xFB, 0xFB, 0xFB, 0xFB, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0x7D, 0x7A, 0xB4, 0x3C, 0xC1, 0x02, 0xDC, 0x1B, 0xB7, 0x2B, 0x57, 0x6F, 0x57, 0x6F, 0x57, 0x6F, 0x57, 0x6F, 0xB7, 0x2F, 0xB7, 0x2F, 0xB7, 0x2F, 0xB7, 0x2F, 0xB7, 0x2F, 0xB7, 0x1B, 0xD7, 0x1B, 0xD7, 0x1B, 0xEF, 0x0C, 0xF3, 0x0E, 0x90, 0x20, 0xA0, 0x00, 0xC0, 0x00, 0xC0, 0x10, 0xC0, 0x30, 0xF8, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF0, 0x10, 0xF0, 0x0C, 0xF8, 0xF8, 0x08, 0xF8, 0x08, 0xFE, 0x04, 0xFF, 0x00, 0xFE, 0x00, 0xFF, 0x00, 0xFF, 0x00, 13 | 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3D, 0x3A, 0x3C, 0x3A, 0x34, 0x38, 0x35, 0x08, 0x13, 0x24, 0x0F, 0x00, 0x03, 0x3C, 0x35, 0x02, 0x01, 0x3D, 0x0F, 0x27, 0x03, 0x1B, 0x13, 0x13, 0x13, 0x1B, 0x13, 0x1B, 0x13, 0x1B, 0x13, 0x1B, 0x01, 0x1D, 0x01, 0x1D, 0x01, 0x1D, 0x01, 0x3E, 0x00, 0x3E, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x1F, 0x00, 0x27, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x10, 0x1F, 0x10, 0x1F, 0x10, 0x1F, 0x1F, 0x10, 0x1F, 0x10, 0x1F, 0x10, 0x1F, 0x10, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 14 | }; 15 | 16 | const uint8_t bitmap_32x32[] PROGMEM = { 17 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xC0, 0xE0, 0xF0, 0x70, 0x70, 0x30, 0x30, 0x30, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF0, 0x70, 0x30, 0x30, 0x20, 0x00, 0x00, 18 | 0x00, 0x30, 0x78, 0xFC, 0x7F, 0x3F, 0x0F, 0x0F, 0x1F, 0x3C, 0x78, 0xF0, 0xE0, 0xC0, 0x80, 0x80, 0x80, 0x40, 0xE0, 0xF0, 0xF8, 0xFC, 0xFF, 0x7F, 0x33, 0x13, 0x1E, 0x1C, 0x1C, 0x0E, 0x07, 0x00, 19 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF9, 0xF7, 0xEF, 0x5F, 0x3F, 0x7F, 0xFE, 0xFD, 0xFB, 0xF1, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 20 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x1E, 0x33, 0x33, 0x1F, 0x0F, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x1F, 0x0E, 0x04, 0x00, 0x00, 0x00, 0x00, 21 | }; 22 | 23 | #include 24 | //GyverOLED oled; 25 | //GyverOLED oled; 26 | //GyverOLED oled; 27 | //GyverOLED oled; 28 | //GyverOLED oled; 29 | GyverOLED oled; 30 | // можно передать адрес: GyverOLED oled(0x3C); 31 | 32 | void setup() { 33 | oled.init(); 34 | oled.clear(); 35 | 36 | // вывод битмапа: (x, y, имя, размерХ, размерУ, инверсия INVERT или не указана) 37 | oled.drawBitmap(0, 0, bitmap_128x64, 128, 64); 38 | oled.drawBitmap(25, 16, bitmap_32x32, 32, 32); 39 | oled.update(); 40 | } 41 | 42 | void loop() { 43 | } 44 | -------------------------------------------------------------------------------- /src/icons_7x7.h: -------------------------------------------------------------------------------- 1 | #ifndef ICONS_7X7_H 2 | #define ICONS_7X7_H 3 | 4 | /** 5 | * Icons 7x7 6 | * 7 | * Между иконками будет отступ 8 | * если использовать setCursor 9 | * 10 | * На Arduino не достаточно памяти для подключения (даже на Mega) 11 | * поэтому копируем те иконки которые нужно (смотрите скетч drawIcons) 12 | */ 13 | 14 | const static uint8_t icons_7x7[][7] PROGMEM = { 15 | {0x7f, 0x45, 0x49, 0x51, 0x49, 0x45, 0x7f}, //0 email 16 | {0x3e, 0x6f, 0x51, 0x01, 0x71, 0x7f, 0x3e}, //1 github 17 | {0x40, 0x60, 0x77, 0x77, 0x77, 0x60, 0x40}, //2 user 18 | {0x70, 0x7e, 0x71, 0x51, 0x71, 0x7e, 0x70}, //3 lock, password 19 | {0x08, 0x3e, 0x36, 0x63, 0x36, 0x3e, 0x08}, //4 cog, settings 20 | {0x3e, 0x63, 0x41, 0x4d, 0x49, 0x63, 0x3e}, //5 clock 21 | {0x0e, 0x11, 0x11, 0x11, 0x3e, 0x60, 0x40}, //6 search 22 | {0x7e, 0x3f, 0x15, 0x15, 0x1d, 0x1f, 0x0e}, //7 message 23 | {0x00, 0x22, 0x14, 0x7f, 0x49, 0x36, 0x00}, //8 bluetooth 24 | {0x1c, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e}, //9 battery 100% 25 | {0x1c, 0x3e, 0x22, 0x3e, 0x3e, 0x3e, 0x3e}, //10 battery 75% 26 | {0x1c, 0x3e, 0x22, 0x22, 0x3e, 0x3e, 0x3e}, //11 battery 50% 27 | {0x1c, 0x3e, 0x22, 0x22, 0x22, 0x3e, 0x3e}, //12 battery 25% 28 | {0x1c, 0x3e, 0x22, 0x22, 0x22, 0x22, 0x3e}, //13 battery 0% 29 | {0x77, 0x41, 0x41, 0x00, 0x41, 0x41, 0x77}, //14 full screen 30 | {0x22, 0x63, 0x00, 0x00, 0x00, 0x63, 0x22}, //15 small screen 31 | {0x02, 0x7a, 0x4b, 0x7b, 0x4b, 0x7a, 0x02}, //16 trash, remove, delete 32 | {0x3c, 0x42, 0x43, 0x52, 0x53, 0x42, 0x3c}, //17 calendar 33 | {0x3e, 0x41, 0x5d, 0x58, 0x54, 0x42, 0x31}, //18 minimize 34 | {0x3e, 0x41, 0x41, 0x48, 0x45, 0x43, 0x37}, //19 maximize 35 | {0x3c, 0x24, 0x77, 0x55, 0x77, 0x24, 0x3c}, //20 printer 36 | {0x1c, 0x1c, 0x1c, 0x22, 0x77, 0x77, 0x77}, //21 share 37 | {0x0c, 0x1e, 0x3b, 0x71, 0x3b, 0x1e, 0x0c}, //22 map 38 | {0x6c, 0x47, 0x6d, 0x6d, 0x6d, 0x47, 0x6c}, //23 case 39 | {0x70, 0x7c, 0x7e, 0x53, 0x7e, 0x7c, 0x70}, //24 warning 40 | {0x1c, 0x3e, 0x77, 0x77, 0x77, 0x3e, 0x1c}, //25 error 41 | {0x3e, 0x41, 0x5d, 0x5d, 0x5d, 0x41, 0x3e}, //26 record 42 | {0x7f, 0x7f, 0x3e, 0x3e, 0x1c, 0x1c, 0x08}, //27 play 43 | {0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f}, //28 stop 44 | {0x00, 0x7f, 0x7f, 0x00, 0x7f, 0x7f, 0x00}, //29 pause 45 | {0x7f, 0x3e, 0x1c, 0x00, 0x7f, 0x3e, 0x1c}, //30 forward 46 | {0x1c, 0x3e, 0x7f, 0x00, 0x1c, 0x3e, 0x7f}, //31 backward 47 | {0x03, 0x07, 0x0f, 0x7f, 0x0f, 0x07, 0x03}, //32 filter 48 | {0x03, 0x05, 0x09, 0x71, 0x09, 0x05, 0x03}, //33 filter out 49 | {0x1c, 0x3e, 0x7f, 0x00, 0x08, 0x22, 0x1c}, //34 sound 100% 50 | {0x1c, 0x3e, 0x7f, 0x00, 0x1c, 0x00, 0x00}, //35 sound 50% 51 | {0x1c, 0x3e, 0x7f, 0x00, 0x00, 0x00, 0x00}, //36 sound 0% 52 | {0x01, 0x02, 0x1c, 0x3e, 0x7f, 0x20, 0x40}, //37 sound off 53 | {0x70, 0x44, 0x48, 0x5f, 0x48, 0x44, 0x70}, //38 download 54 | {0x70, 0x44, 0x42, 0x5f, 0x42, 0x44, 0x70}, //39 upload 55 | {0x3e, 0x41, 0x41, 0x4f, 0x49, 0x4a, 0x3c}, //40 text upload 56 | {0x70, 0x48, 0x50, 0x2a, 0x05, 0x09, 0x07}, //41 link 57 | {0x70, 0x48, 0x44, 0x26, 0x19, 0x0a, 0x04}, //42 pencil 58 | {0x7e, 0x3f, 0x1f, 0x0f, 0x1f, 0x3f, 0x7e}, //43 bookmark 59 | {0x08, 0x4c, 0x6e, 0x7f, 0x3b, 0x19, 0x08}, //44 flash, lighting 60 | {0x3e, 0x41, 0x49, 0x55, 0x55, 0x51, 0x4e}, //45 attach 61 | {0x0e, 0x1f, 0x3e, 0x7c, 0x3e, 0x1f, 0x0e}, //46 heart 62 | {0x0e, 0x11, 0x22, 0x44, 0x22, 0x11, 0x0e}, //47 heart out 63 | {0x32, 0x33, 0x33, 0x7f, 0x33, 0x33, 0x23}, //48 direction 64 | {0x08, 0x14, 0x22, 0x2a, 0x22, 0x14, 0x08}, //49 eye, visible 65 | {0x02, 0x05, 0x09, 0x7f, 0x09, 0x05, 0x02}, //50 antenna 66 | {0x60, 0x00, 0x70, 0x00, 0x7c, 0x00, 0x7f}, //51 mobile network 100% 67 | {0x60, 0x00, 0x70, 0x00, 0x7c, 0x00, 0x40}, //52 mobile network 75% 68 | {0x60, 0x00, 0x70, 0x00, 0x40, 0x00, 0x40}, //53 mobile network 50% 69 | {0x60, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40}, //54 mobile network 25% 70 | {0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40}, //55 mobile network 0% 71 | {0x10, 0x20, 0x7f, 0x00, 0x7f, 0x02, 0x04}, //56 sync 72 | {0x3e, 0x3e, 0x3e, 0x1c, 0x08, 0x1c, 0x3e}, //57 video 73 | {0x02, 0x09, 0x25, 0x15, 0x25, 0x09, 0x02}, //58 wifi 74 | {0x38, 0x44, 0x42, 0x52, 0x4c, 0x48, 0x30}, //59 cloud 75 | {0x01, 0x0a, 0x78, 0x7b, 0x78, 0x0a, 0x01}, //60 flashlight on 76 | {0x00, 0x08, 0x78, 0x48, 0x78, 0x08, 0x00}, //61 flashlight off 77 | {0x38, 0x26, 0x61, 0x61, 0x61, 0x26, 0x38}, //62 bell 78 | {0x70, 0x7e, 0x71, 0x51, 0x71, 0x72, 0x70}, //63 unlock 79 | {0x1c, 0x00, 0x7f, 0x41, 0x7f, 0x00, 0x1c}, //64 vibrate 80 | {0x3e, 0x41, 0x49, 0x51, 0x49, 0x44, 0x32}, //65 checked 81 | {0x3e, 0x41, 0x41, 0x41, 0x41, 0x41, 0x3e}, //66 unchecked 82 | {0x2a, 0x00, 0x7f, 0x41, 0x7f, 0x00, 0x2a}, //67 chip 83 | {0x28, 0x28, 0x7d, 0x42, 0x7d, 0x28, 0x28}, //68 bug 84 | {0x7f, 0x49, 0x69, 0x69, 0x69, 0x4a, 0x7c}, //69 save 85 | {0x7e, 0x52, 0x4a, 0x4a, 0x6c, 0x18, 0x08}, //70 open 86 | {0x60, 0x70, 0x3e, 0x19, 0x11, 0x10, 0x0c}, //71 tool 87 | {0x7f, 0x75, 0x5b, 0x5f, 0x5f, 0x5f, 0x7f}, //72 console 88 | {0x49, 0x49, 0x00, 0x49, 0x49, 0x49, 0x49}, //73 todo, list 89 | {0x77, 0x77, 0x77, 0x00, 0x72, 0x77, 0x72}, //74 apps 90 | {0x71, 0x4a, 0x64, 0x44, 0x64, 0x4a, 0x71}, //75 android 91 | {0x00, 0x06, 0x39, 0x51, 0x39, 0x06, 0x00}, //76 bulb 92 | {0x3e, 0x41, 0x49, 0x08, 0x2a, 0x1c, 0x08}, //77 logout 93 | {0x08, 0x2a, 0x1c, 0x49, 0x41, 0x41, 0x3e}, //78 login 94 | {0x3e, 0x41, 0x49, 0x5d, 0x49, 0x61, 0x7e}, //79 zoom in 95 | {0x3e, 0x41, 0x49, 0x49, 0x69, 0x71, 0x7e}, //80 zoom out 96 | {0x7f, 0x7f, 0x7f, 0x00, 0x77, 0x77, 0x77}, //81 dashboard 97 | {0x63, 0x49, 0x1c, 0x3e, 0x1c, 0x49, 0x63}, //82 all out 98 | {0x60, 0x70, 0x79, 0x7f, 0x79, 0x70, 0x60}, //83 science 99 | {0x1c, 0x22, 0x51, 0x49, 0x45, 0x22, 0x1c}, //84 block 100 | {0x3f, 0x42, 0x54, 0x44, 0x54, 0x42, 0x3f}, //85 cat, fox 101 | {0x02, 0x05, 0x02, 0x38, 0x44, 0x44, 0x28}, //86 celsius 102 | {0x02, 0x05, 0x02, 0x08, 0x7c, 0x48, 0x60}, //87 temperature 103 | {0x02, 0x05, 0x02, 0x7c, 0x10, 0x28, 0x44}, //88 kelvin 104 | {0x14, 0x14, 0x7f, 0x14, 0x7f, 0x14, 0x14}, //89 tag 105 | {0x00, 0x41, 0x63, 0x36, 0x1c, 0x08, 0x00}, //90 chevron right 106 | {0x00, 0x08, 0x1c, 0x36, 0x63, 0x41, 0x00}, //91 chevron left 107 | {0x30, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30}, //92 chevron up 108 | {0x06, 0x0c, 0x18, 0x30, 0x18, 0x0c, 0x06}, //93 chevron down 109 | {0x00, 0x30, 0x48, 0x48, 0x3f, 0x00, 0x00}, //94 note 1 110 | {0x00, 0x30, 0x78, 0x78, 0x3f, 0x00, 0x00}, //95 note 2 111 | {0x00, 0x30, 0x48, 0x48, 0x3f, 0x01, 0x00}, //96 note 3 112 | {0x00, 0x30, 0x78, 0x78, 0x3f, 0x01, 0x00}, //97 note 4 113 | {0x00, 0x30, 0x48, 0x48, 0x3f, 0x05, 0x00}, //98 note 5 114 | {0x00, 0x30, 0x78, 0x78, 0x3f, 0x05, 0x00}, //99 note 6 115 | {0x3f, 0x41, 0x41, 0x41, 0x3f, 0x12, 0x0e}, //100 cup empty 116 | {0x3f, 0x61, 0x61, 0x61, 0x3f, 0x12, 0x0e}, //101 cup 20% 117 | {0x3f, 0x71, 0x71, 0x71, 0x3f, 0x12, 0x0e}, //102 cup 40% 118 | {0x3f, 0x79, 0x79, 0x79, 0x3f, 0x12, 0x0e}, //103 cup 60% 119 | {0x3f, 0x7d, 0x7d, 0x7d, 0x3f, 0x12, 0x0e}, //104 cup 80% 120 | {0x3f, 0x7f, 0x7f, 0x7f, 0x3f, 0x12, 0x0e}, //105 cup 100% 121 | {0x07, 0x09, 0x51, 0x71, 0x51, 0x09, 0x07}, //106 wine class 122 | {0x07, 0x39, 0x41, 0x41, 0x41, 0x39, 0x07}, //107 glass 123 | {0x04, 0x06, 0x7f, 0x7f, 0x7f, 0x02, 0x07}, //108 hammer 124 | {0x7f, 0x41, 0x41, 0x42, 0x42, 0x42, 0x7c}, //109 folder outline 125 | {0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7c}, //110 folder 126 | {0x7f, 0x41, 0x41, 0x52, 0x7a, 0x52, 0x7c}, //111 add folder 127 | {0x0c, 0x18, 0x10, 0x77, 0x10, 0x18, 0x0c}, //112 microphone 128 | {0x70, 0x00, 0x7f, 0x00, 0x7c, 0x00, 0x7e}, //113 equalizer 129 | {0x7f, 0x7f, 0x3e, 0x1c, 0x08, 0x00, 0x7f}, //114 next 130 | {0x7f, 0x00, 0x08, 0x1c, 0x3e, 0x7f, 0x7f}, //115 prev 131 | {0x1f, 0x51, 0x51, 0x71, 0x51, 0x51, 0x1f}, //116 monitor, display 132 | {0x3c, 0x72, 0x71, 0x01, 0x71, 0x72, 0x3c}, //117 headset, earphones 133 | {0x1c, 0x3e, 0x08, 0x08, 0x08, 0x3e, 0x1c}, //118 workout, fitness 134 | {0x7f, 0x0a, 0x05, 0x0a, 0x05, 0x0a, 0x05}, //119 sport flag 135 | {0x08, 0x08, 0x14, 0x63, 0x14, 0x08, 0x08}, //120 location 136 | {0x60, 0x70, 0x78, 0x7c, 0x7e, 0x01, 0x5d}, //121 cellular 1 137 | {0x60, 0x50, 0x48, 0x44, 0x42, 0x01, 0x5d}, //122 cellular 2 138 | {0x60, 0x50, 0x48, 0x44, 0x42, 0x41, 0x7f}, //123 cellular 3 139 | {0x60, 0x70, 0x78, 0x7c, 0x7e, 0x7f, 0x7f}, //124 cellular 4 140 | {0x23, 0x36, 0x3c, 0x38, 0x36, 0x6f, 0x5f}, //125 cellular 5 141 | {0x60, 0x70, 0x78, 0x04, 0x56, 0x27, 0x57}, //126 cellular 6 142 | {0x44, 0x22, 0x22, 0x44, 0x22, 0x22, 0x44}, //127 waves 143 | {0x18, 0x74, 0x52, 0x51, 0x52, 0x74, 0x18}, //128 home 144 | {0x3e, 0x41, 0x55, 0x41, 0x55, 0x41, 0x3e}, //129 dice 1 145 | {0x3e, 0x41, 0x45, 0x41, 0x51, 0x41, 0x3e}, //130 dice 2 146 | {0x1c, 0x27, 0x24, 0x64, 0x24, 0x27, 0x1c}, //131 plug 147 | {0x78, 0x44, 0x42, 0x41, 0x52, 0x44, 0x78}, //132 home 2 148 | {0x70, 0x50, 0x71, 0x52, 0x54, 0x58, 0x70}, //133 radio 149 | {0x14, 0x3e, 0x63, 0x2a, 0x63, 0x3e, 0x14}, //134 memory 150 | {0x49, 0x5d, 0x49, 0x41, 0x51, 0x45, 0x41}, //135 gamepad 151 | {0x78, 0x48, 0x6a, 0x49, 0x6d, 0x49, 0x7a}, //136 router 152 | {0x3e, 0x41, 0x55, 0x61, 0x55, 0x41, 0x3e}, //137 smile 1 153 | {0x3e, 0x41, 0x65, 0x51, 0x65, 0x41, 0x3e}, //138 smile 2 154 | {0x3e, 0x41, 0x55, 0x51, 0x55, 0x41, 0x3e}, //139 smile 3 155 | {0x3e, 0x41, 0x45, 0x51, 0x45, 0x41, 0x3e}, //140 smile 4 156 | {0x3e, 0x41, 0x4d, 0x61, 0x4d, 0x41, 0x3e}, //141 smile 5 157 | {0x01, 0x03, 0x7f, 0x5d, 0x55, 0x55, 0x7f}, //142 sms 158 | {0x1e, 0x3f, 0x3f, 0x3f, 0x33, 0x33, 0x1e}, //143 toggle on 159 | {0x1e, 0x2d, 0x2d, 0x21, 0x21, 0x21, 0x1e}, //144 toggle off 160 | {0x00, 0x00, 0x7f, 0x3e, 0x1c, 0x08, 0x00}, //145 arrow type 1 right 161 | {0x00, 0x08, 0x1c, 0x3e, 0x7f, 0x00, 0x00}, //146 arrow type 1 left 162 | {0x04, 0x0c, 0x1c, 0x3c, 0x1c, 0x0c, 0x04}, //147 arrow type 1 down 163 | {0x10, 0x18, 0x1c, 0x1e, 0x1c, 0x18, 0x10}, //148 arrow type 1 up 164 | {0x08, 0x08, 0x08, 0x7f, 0x3e, 0x1c, 0x08}, //149 arrow type 2 right 165 | {0x08, 0x1c, 0x3e, 0x7f, 0x08, 0x08, 0x08}, //150 arrow type 2 left 166 | {0x08, 0x18, 0x38, 0x7f, 0x38, 0x18, 0x08}, //151 arrow type 2 down 167 | {0x08, 0x0c, 0x0e, 0x7f, 0x0e, 0x0c, 0x08}, //152 arrow type 2 up 168 | {0x02, 0x39, 0x44, 0x54, 0x44, 0x39, 0x02}, //153 alarm clock 169 | {0x1c, 0x22, 0x1c, 0x08, 0x18, 0x08, 0x38}, //154 key 170 | }; 171 | 172 | 173 | #endif //ICONS_7X7_H 174 | -------------------------------------------------------------------------------- /src/icons_8x8.h: -------------------------------------------------------------------------------- 1 | #ifndef ICONS_8X8_H 2 | #define ICONS_8X8_H 3 | 4 | 5 | /** 6 | * Icons 8x8 7 | * 8 | * Эти иконки занимают всю высоту и ширину ячейки 9 | * соответственно между двумя иконками подряд не будет отступа 10 | * если использовать setCursor 11 | * 12 | * На Arduino не достаточно памяти для подключения (даже на Mega) 13 | * поэтому копируем те иконки которые нужно (смотрите скетч drawIcons) 14 | */ 15 | 16 | const static uint8_t icons_8x8[][8] PROGMEM = { 17 | {0xff, 0x85, 0x89, 0x91, 0x91, 0x89, 0x85, 0xff}, //0 email 18 | {0x3c, 0x5e, 0xa3, 0x03, 0x03, 0xe3, 0x7e, 0x3c}, //1 github 19 | {0x80, 0xc0, 0xe6, 0xef, 0xef, 0xe6, 0xc0, 0x80}, //2 user 20 | {0xf0, 0xfe, 0xf1, 0x91, 0x91, 0xf1, 0xfe, 0xf0}, //3 lock, password 21 | {0x18, 0x7e, 0x7e, 0xe7, 0xe7, 0x7e, 0x7e, 0x18}, //4 cog, settings 22 | {0x3c, 0x42, 0x81, 0x9d, 0x91, 0x91, 0x42, 0x3c}, //5 clock 23 | {0x1e, 0x33, 0x21, 0x21, 0x33, 0x7e, 0xe0, 0xc0}, //6 search 24 | {0x7e, 0x3f, 0x15, 0x15, 0x15, 0x1d, 0x1f, 0x0e}, //7 message 25 | {0x00, 0x42, 0x24, 0x18, 0xff, 0x99, 0x66, 0x00}, //8 bluetooth 26 | {0x00, 0x3c, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e},//9 battery 100% 27 | {0x00, 0x3c, 0x7e, 0x42, 0x7e, 0x7e, 0x7e, 0x7e},//10 battery 75% 28 | {0x00, 0x3c, 0x7e, 0x42, 0x42, 0x7e, 0x7e, 0x7e},//11 battery 50% 29 | {0x00, 0x3c, 0x7e, 0x42, 0x42, 0x42, 0x7e, 0x7e},//12 battery 25% 30 | {0x00, 0x3c, 0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e},//13 battery 0% 31 | {0xe7, 0x81, 0x81, 0x00, 0x00, 0x81, 0x81, 0xe7}, //14 full screen 32 | {0x24, 0x24, 0xe7, 0x00, 0x00, 0xe7, 0x24, 0x24}, //15 small screen 33 | {0x02, 0xfa, 0x8b, 0xfb, 0xfb, 0x8b, 0xfa, 0x02}, //16 trash, remove, delete 34 | {0x7c, 0x82, 0x83, 0x82, 0xb2, 0xb3, 0x82, 0x7c}, //17 calendar 35 | {0x7e, 0x81, 0x81, 0x9d, 0x98, 0x94, 0x82, 0x71}, //18 minimize 36 | {0x7e, 0x81, 0x81, 0x91, 0x88, 0x85, 0x83, 0x77}, //19 maximize 37 | {0x7c, 0x44, 0xe7, 0xa5, 0xa5, 0xe7, 0x44, 0x7c}, //20 printer 38 | {0x00, 0x18, 0x18, 0x24, 0x24, 0xc3, 0xc3, 0x00}, //21 share 39 | {0x1c, 0x3e, 0x73, 0xe1, 0xe1, 0x73, 0x3e, 0x1c}, //22 map 40 | {0xd8, 0x88, 0xde, 0xda, 0xda, 0xde, 0x88, 0xd8}, //23 case 41 | {0xe0, 0xfc, 0xfe, 0xa3, 0xfe, 0xfc, 0xe0, 0x00}, //24 warning 42 | {0x3c, 0x7e, 0xe7, 0xe7, 0xe7, 0xe7, 0x7e, 0x3c}, //25 error 43 | {0x3c, 0x42, 0x81, 0x99, 0x99, 0x81, 0x42, 0x3c}, //26 record 44 | {0xff, 0xff, 0xff, 0x7e, 0x7e, 0x3c, 0x3c, 0x18}, //27 play 45 | {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, //28 stop 46 | {0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00}, //29 pause 47 | {0xff, 0x7e, 0x3c, 0x18, 0xff, 0x7e, 0x3c, 0x18}, //30 forward 48 | {0x18, 0x3c, 0x7e, 0xff, 0x18, 0x3c, 0x7e, 0xff}, //31 backward 49 | {0x07, 0x0f, 0x1f, 0xff, 0xff, 0x1f, 0x0f, 0x07}, //32 filter 50 | {0x07, 0x09, 0x11, 0xe1, 0xe1, 0x11, 0x09, 0x07}, //33 filter outline 51 | {0x3c, 0x7e, 0xff, 0x00, 0x18, 0x42, 0x3c, 0x00}, //34 sound 100% 52 | {0x3c, 0x7e, 0xff, 0x00, 0x18, 0x00, 0x00, 0x00}, //35 sound 50% 53 | {0x3c, 0x7e, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00}, //36 sound 0% 54 | {0x01, 0x02, 0x3c, 0x7e, 0xff, 0x20, 0x40, 0x80}, //37 sound off 55 | {0xe0, 0x88, 0x90, 0xbf, 0xbf, 0x90, 0x88, 0xe0}, //38 download 56 | {0xe0, 0x84, 0x82, 0xbf, 0xbf, 0x82, 0x84, 0xe0}, //39 upload 57 | {0x7e, 0x81, 0xa1, 0xa1, 0xaf, 0xa9, 0x8a, 0x7c}, //40 text file 58 | {0xf0, 0x88, 0xa0, 0x92, 0x49, 0x05, 0x11, 0x0f}, //41 link 59 | {0xe0, 0x90, 0x88, 0x44, 0x26, 0x19, 0x0a, 0x04}, //42 pencil 60 | {0xfe, 0x7f, 0x3f, 0x1f, 0x1f, 0x3f, 0x7f, 0xfe}, //43 bookmark 61 | {0x00, 0x98, 0xdc, 0xfe, 0x7f, 0x3b, 0x19, 0x18}, //44 flash, lighting 62 | {0x7e, 0x81, 0x99, 0xa5, 0xa5, 0xa5, 0xa1, 0x9e}, //45 attach 63 | {0x1e, 0x3f, 0x7f, 0xfe, 0xfe, 0x7f, 0x3f, 0x1e}, //46 heart 64 | {0x1e, 0x21, 0x41, 0x82, 0x82, 0x41, 0x21, 0x1e}, //47 heart outline 65 | {0x72, 0x77, 0x77, 0xff, 0xff, 0x77, 0x77, 0x27}, //48 direction 66 | {0x18, 0x24, 0x42, 0x5a, 0x5a, 0x42, 0x24, 0x18}, //49 eye, visible 67 | {0x06, 0x09, 0x11, 0xff, 0xff, 0x11, 0x09, 0x06}, //50 antenna 68 | {0x00, 0xe0, 0x00, 0xf0, 0x00, 0xfc, 0x00, 0xff}, //51 mobile network 100% 69 | {0x00, 0xe0, 0x00, 0xf0, 0x00, 0xfc, 0x00, 0x80}, //52 mobile network 75% 70 | {0x00, 0xe0, 0x00, 0xf0, 0x00, 0x80, 0x00, 0x80}, //53 mobile network 50% 71 | {0x00, 0xe0, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80}, //54 mobile network 25% 72 | {0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80}, //55 mobile network 0% 73 | {0x20, 0x40, 0xff, 0x00, 0x00, 0xff, 0x02, 0x04}, //56 sync 74 | {0x7e, 0x7e, 0x7e, 0x7e, 0x3c, 0x18, 0x3c, 0x7e}, //57 video 75 | {0x02, 0x09, 0x25, 0x95, 0x95, 0x25, 0x09, 0x02}, //58 wifi 76 | {0x70, 0x88, 0x84, 0x84, 0xa4, 0x98, 0x90, 0x60}, //59 cloud 77 | {0x01, 0x0a, 0xf8, 0xfb, 0xf8, 0x0a, 0x01, 0x00}, //60 flashlight on 78 | {0x00, 0x08, 0xf8, 0x88, 0xf8, 0x08, 0x00, 0x00}, //61 flashlight off 79 | {0x70, 0x4e, 0x41, 0xc1, 0xc1, 0x41, 0x4e, 0x70}, //62 bell 80 | {0xf0, 0xfe, 0xf1, 0x91, 0x91, 0xf1, 0xf2, 0xf0}, //63 unlock 81 | {0x3c, 0x00, 0xff, 0x81, 0x81, 0xff, 0x00, 0x3c}, //64 vibrate 82 | {0x7e, 0x81, 0x91, 0xa1, 0x91, 0x89, 0x84, 0x72}, //65 checked 83 | {0x7e, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x7e}, //66 unchecked 84 | {0x54, 0x00, 0xff, 0x81, 0x81, 0xff, 0x00, 0x54}, //67 chip 85 | {0x48, 0x48, 0xfd, 0x82, 0x82, 0xfd, 0x48, 0x48}, //68 bug 86 | {0xff, 0x89, 0xe9, 0xa9, 0xa9, 0xe9, 0x8a, 0xfc}, //69 save 87 | {0xfe, 0xa2, 0x92, 0x8a, 0x8a, 0xcc, 0x28, 0x18}, //70 open 88 | {0xc0, 0xe0, 0x70, 0x3e, 0x19, 0x11, 0x10, 0x0c}, //71 tool 89 | {0xff, 0xdd, 0xeb, 0xb7, 0xbf, 0xbf, 0xbf, 0xff}, //72 console 90 | {0xdb, 0xdb, 0x00, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb}, //73 todo, list 91 | {0xe7, 0xe7, 0xe7, 0x00, 0x00, 0xe2, 0xe7, 0xe2}, //74 apps 92 | {0xf1, 0x8a, 0xa4, 0x84, 0x84, 0xa4, 0x8a, 0xf1}, //75 android 93 | {0x00, 0x0e, 0x71, 0xa1, 0xa1, 0x71, 0x0e, 0x00}, //76 bulb 94 | {0x7e, 0x81, 0x99, 0x99, 0x18, 0x5a, 0x3c, 0x18}, //77 logout 95 | {0x18, 0x18, 0x5a, 0x3c, 0x99, 0x81, 0x81, 0x7e}, //78 login 96 | {0x3e, 0x41, 0x49, 0x5d, 0x49, 0x41, 0xfe, 0xc0}, //79 zoom in 97 | {0x3e, 0x41, 0x49, 0x49, 0x49, 0x41, 0xfe, 0xc0}, //80 zoom out 98 | {0xff, 0xff, 0xff, 0x00, 0xf7, 0xf7, 0xf7, 0xf7}, //81 dashboard 99 | {0xc3, 0x99, 0x3c, 0x7e, 0x7e, 0x3c, 0x99, 0xc3}, //82 all out 100 | {0xc0, 0xe0, 0xf1, 0xff, 0xff, 0xf1, 0xe0, 0xc0}, //83 science 101 | {0x3c, 0x42, 0xa1, 0x91, 0x89, 0x85, 0x42, 0x3c}, //84 block 102 | {0x7f, 0x82, 0xb4, 0x84, 0x84, 0xb4, 0x82, 0x7f}, //85 cat, fox 103 | {0x06, 0x09, 0x09, 0x06, 0x78, 0x84, 0x84, 0x48}, //86 celsius 104 | {0x06, 0x09, 0x09, 0x06, 0x08, 0xfc, 0x88, 0xc0}, //87 temperature 105 | {0x06, 0x09, 0x09, 0x06, 0xf8, 0x20, 0x50, 0x88}, //88 kelvin 106 | {0x24, 0x24, 0xff, 0x24, 0x24, 0xff, 0x24, 0x24}, //89 tag 107 | {0x00, 0x00, 0x81, 0xc3, 0x66, 0x3c, 0x18, 0x00}, //90 chevron right 108 | {0x00, 0x18, 0x3c, 0x66, 0xc3, 0x81, 0x00, 0x00}, //91 chevron left 109 | {0x30, 0x18, 0x0c, 0x06, 0x06, 0x0c, 0x18, 0x30}, //92 chevron up 110 | {0x0c, 0x18, 0x30, 0x60, 0x60, 0x30, 0x18, 0x0c}, //93 chevron down 111 | {0x00, 0x60, 0x90, 0x90, 0x7f, 0x00, 0x00, 0x00}, //94 note 1 112 | {0x00, 0x60, 0xf0, 0xf0, 0x7f, 0x00, 0x00, 0x00}, //95 note 2 113 | {0x00, 0x60, 0x90, 0x90, 0x7f, 0x01, 0x01, 0x00}, //96 note 3 114 | {0x00, 0x60, 0xf0, 0xf0, 0x7f, 0x01, 0x01, 0x00}, //97 note 4 115 | {0x00, 0x60, 0x90, 0x90, 0x7f, 0x05, 0x05, 0x00}, //98 note 5 116 | {0x00, 0x60, 0xf0, 0xf0, 0x7f, 0x05, 0x05, 0x00}, //99 note 6 117 | {0x7f, 0x81, 0x81, 0x81, 0x81, 0x7f, 0x22, 0x1e}, //100 cup empty 118 | {0x7f, 0xe1, 0xe1, 0xe1, 0xe1, 0x7f, 0x22, 0x1e}, //101 cup 20% 119 | {0x7f, 0xf1, 0xf1, 0xf1, 0xf1, 0x7f, 0x22, 0x1e}, //102 cup 40% 120 | {0x7f, 0xf9, 0xf9, 0xf9, 0xf9, 0x7f, 0x22, 0x1e}, //103 cup 60% 121 | {0x7f, 0xfd, 0xfd, 0xfd, 0xfd, 0x7f, 0x22, 0x1e}, //104 cup 80% 122 | {0x7f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x22, 0x1e}, //105 cup 100% 123 | {0x07, 0x09, 0x91, 0xe1, 0xe1, 0x91, 0x09, 0x07}, //106 wineglass 124 | {0x07, 0x19, 0xe1, 0x81, 0x81, 0xe1, 0x19, 0x07}, //107 glass 125 | {0x04, 0x06, 0xff, 0xff, 0xff, 0x06, 0x0f, 0x0f}, //108 hammer 126 | {0xff, 0x81, 0x81, 0x81, 0x82, 0x82, 0x82, 0xfc}, //109 folder outline 127 | {0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfc}, //110 folder 128 | {0xff, 0x81, 0x81, 0x91, 0xba, 0x92, 0x82, 0xfc}, //111 add folder 129 | {0x1c, 0x30, 0x20, 0xef, 0xef, 0x20, 0x30, 0x1c}, //112 microphone 130 | {0xe0, 0xe0, 0x00, 0xff, 0xff, 0x00, 0xfc, 0xfc}, //113 equalizer 131 | {0xff, 0xff, 0xff, 0x7e, 0x3c, 0x18, 0x00, 0xff}, //114 next 132 | {0xff, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0xff}, //115 prev 133 | {0x3f, 0xa1, 0xa1, 0xe1, 0xe1, 0xa1, 0xa1, 0x3f}, //116 monitor, display 134 | {0x7c, 0xe2, 0xe1, 0x01, 0x01, 0xe1, 0xe2, 0x7c}, //117 headset, earphones 135 | {0x18, 0x3c, 0x7e, 0x18, 0x18, 0x7e, 0x3c, 0x18}, //118 workout, fitness 136 | {0xff, 0x0a, 0x15, 0x0a, 0x15, 0x0a, 0x15, 0x0a}, //119 sport flag 137 | {0x18, 0x18, 0x24, 0xc3, 0xc3, 0x24, 0x18, 0x18}, //120 location 138 | {0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0x01, 0xbd}, //121 cellular 1 139 | {0xc0, 0xa0, 0x90, 0x88, 0x84, 0x82, 0x01, 0xbd}, //122 cellular 2 140 | {0xc0, 0xa0, 0x90, 0x88, 0x84, 0x82, 0x81, 0xff}, //123 cellular 3 141 | {0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff, 0xff}, //124 cellular 4 142 | {0x43, 0x66, 0x7c, 0x78, 0x74, 0x6e, 0xdf, 0xbf}, //125 cellular 5 143 | {0xc0, 0xe0, 0xf0, 0xf8, 0x0c, 0xae, 0x4f, 0xaf}, //126 cellular 6 144 | {0x92, 0x49, 0x49, 0x92, 0x92, 0x49, 0x49, 0x92}, //127 waves 145 | {0x18, 0xf4, 0x92, 0x91, 0x91, 0x92, 0xf4, 0x18}, //128 home 146 | {0x7e, 0x81, 0xa5, 0x81, 0x81, 0xa5, 0x81, 0x7e}, //129 dice 1 147 | {0x7e, 0x81, 0x85, 0x81, 0x81, 0xa1, 0x81, 0x7e}, //130 dice 2 148 | {0x3c, 0x44, 0x47, 0xc4, 0xc4, 0x47, 0x44, 0x3c}, //131 plug 149 | {0xf8, 0x84, 0x82, 0x81, 0xb1, 0xb2, 0x84, 0xf8}, //132 home 2 150 | {0xf0, 0x90, 0xf0, 0xf1, 0x92, 0x94, 0x98, 0xf0}, //133 radio 151 | {0x24, 0x7e, 0xc3, 0x5a, 0x5a, 0xc3, 0x7e, 0x24}, //134 memory 152 | {0x44, 0x92, 0xba, 0x92, 0x82, 0xaa, 0x82, 0x44}, //135 gamepad 153 | {0x70, 0x88, 0xa8, 0x8a, 0xa9, 0x8d, 0x89, 0x72}, //136 router 154 | {0x7e, 0x81, 0x95, 0xa1, 0xa1, 0x95, 0x81, 0x7e}, //137 smile 1 155 | {0x7e, 0x81, 0xa5, 0x91, 0x91, 0xa5, 0x81, 0x7e}, //138 smile 2 156 | {0x7e, 0x81, 0xa5, 0xa1, 0xa1, 0xa5, 0x81, 0x7e}, //139 smile 3 157 | {0x7e, 0x81, 0x85, 0xb1, 0xb1, 0x85, 0x81, 0x7e}, //140 smile 4 158 | {0x7e, 0x81, 0x8d, 0xe1, 0xe1, 0x8d, 0x81, 0x7e}, //141 smile 5 159 | {0x01, 0x03, 0xff, 0xfb, 0xbb, 0xab, 0xab, 0xff}, //142 sms 160 | {0x3c, 0x7e, 0x7e, 0x7e, 0x7e, 0x66, 0x66, 0x3c}, //143 toggle on 161 | {0x3c, 0x5a, 0x5a, 0x42, 0x42, 0x42, 0x42, 0x3c}, //144 toggle off 162 | {0x00, 0x00, 0xff, 0x7e, 0x3c, 0x18, 0x00, 0x00}, //145 arrow type 1 right 163 | {0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0x00, 0x00}, //146 arrow type 1 left 164 | {0x04, 0x0c, 0x1c, 0x3c, 0x3c, 0x1c, 0x0c, 0x04}, //147 arrow type 1 down 165 | {0x20, 0x30, 0x38, 0x3c, 0x3c, 0x38, 0x30, 0x20}, //148 arrow type 1 up 166 | {0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18}, //149 arrow type 2 right 167 | {0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18}, //150 arrow type 2 left 168 | {0x10, 0x30, 0x70, 0xff, 0xff, 0x70, 0x30, 0x10}, //151 arrow type 2 down 169 | {0x08, 0x0c, 0x0e, 0xff, 0xff, 0x0e, 0x0c, 0x08}, //152 arrow type 2 up 170 | {0x02, 0x79, 0x85, 0xb4, 0xa4, 0x85, 0x79, 0x02}, //153 alarm clock 171 | {0x3c, 0x42, 0x42, 0x3c, 0x08, 0x18, 0x08, 0x38}, //154 key 172 | }; 173 | 174 | #endif //ICONS_8X8_H 175 | -------------------------------------------------------------------------------- /src/charMap.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | // шрифты для вывода текста 3 | const uint8_t _charMap[][5] PROGMEM = { 4 | {0x00, 0x00, 0x00, 0x00, 0x00}, // 0x20 32 5 | {0x00, 0x00, 0x6f, 0x00, 0x00}, // ! 0x21 33 6 | {0x00, 0x07, 0x00, 0x07, 0x00}, // " 0x22 34 7 | {0x14, 0x7f, 0x14, 0x7f, 0x14}, // # 0x23 35 8 | {0x8C, 0x92, 0xFF, 0x92, 0x62}, // $ 0x24 36 9 | {0x23, 0x13, 0x08, 0x64, 0x62}, // % 0x25 37 10 | {0x36, 0x49, 0x56, 0x20, 0x50}, // & 0x26 38 11 | {0x00, 0x00, 0x07, 0x00, 0x00}, // ' 0x27 39 12 | {0x00, 0x1c, 0x22, 0x41, 0x00}, // ( 0x28 40 13 | {0x00, 0x41, 0x22, 0x1c, 0x00}, // ) 0x29 41 14 | {0x14, 0x08, 0x3e, 0x08, 0x14}, // * 0x2a 42 15 | {0x08, 0x08, 0x3e, 0x08, 0x08}, // + 0x2b 43 16 | {0x00, 0x50, 0x30, 0x00, 0x00}, // , 0x2c 44 17 | {0x08, 0x08, 0x08, 0x08, 0x08}, // - 0x2d 45 18 | {0x00, 0x60, 0x60, 0x00, 0x00}, // . 0x2e 46 19 | {0x20, 0x10, 0x08, 0x04, 0x02}, // / 0x2f 47 20 | {0x3e, 0x51, 0x49, 0x45, 0x3e}, // 0 0x30 48 21 | {0x00, 0x42, 0x7f, 0x40, 0x00}, // 1 0x31 49 22 | {0x42, 0x61, 0x51, 0x49, 0x46}, // 2 0x32 50 23 | {0x21, 0x41, 0x45, 0x4b, 0x31}, // 3 0x33 51 24 | {0x18, 0x14, 0x12, 0x7f, 0x10}, // 4 0x34 52 25 | {0x27, 0x45, 0x45, 0x45, 0x39}, // 5 0x35 53 26 | {0x3c, 0x4a, 0x49, 0x49, 0x30}, // 6 0x36 54 27 | {0x01, 0x71, 0x09, 0x05, 0x03}, // 7 0x37 55 28 | {0x36, 0x49, 0x49, 0x49, 0x36}, // 8 0x38 56 29 | {0x06, 0x49, 0x49, 0x29, 0x1e}, // 9 0x39 57 30 | {0x00, 0x36, 0x36, 0x00, 0x00}, // : 0x3a 58 31 | {0x00, 0x56, 0x36, 0x00, 0x00}, // ; 0x3b 59 32 | {0x08, 0x14, 0x22, 0x41, 0x00}, // < 0x3c 60 33 | {0x14, 0x14, 0x14, 0x14, 0x14}, // = 0x3d 61 34 | {0x00, 0x41, 0x22, 0x14, 0x08}, // > 0x3e 62 35 | {0x02, 0x01, 0x51, 0x09, 0x06}, // ? 0x3f 63 36 | {0x3e, 0x41, 0x5d, 0x49, 0x4e}, // @ 0x40 64 37 | {0x7e, 0x09, 0x09, 0x09, 0x7e}, // A 0x41 65 38 | {0x7f, 0x49, 0x49, 0x49, 0x36}, // B 0x42 66 39 | {0x3e, 0x41, 0x41, 0x41, 0x22}, // C 0x43 67 40 | {0x7f, 0x41, 0x41, 0x41, 0x3e}, // D 0x44 68 41 | {0x7f, 0x49, 0x49, 0x49, 0x41}, // E 0x45 69 42 | {0x7f, 0x09, 0x09, 0x09, 0x01}, // F 0x46 70 43 | {0x3e, 0x41, 0x49, 0x49, 0x7a}, // G 0x47 71 44 | {0x7f, 0x08, 0x08, 0x08, 0x7f}, // H 0x48 72 45 | {0x00, 0x41, 0x7f, 0x41, 0x00}, // I 0x49 73 46 | {0x20, 0x40, 0x41, 0x3f, 0x01}, // J 0x4a 74 47 | {0x7f, 0x08, 0x14, 0x22, 0x41}, // K 0x4b 75 48 | {0x7f, 0x40, 0x40, 0x40, 0x40}, // L 0x4c 76 49 | {0x7f, 0x02, 0x0c, 0x02, 0x7f}, // M 0x4d 77 50 | {0x7f, 0x04, 0x08, 0x10, 0x7f}, // N 0x4e 78 51 | {0x3e, 0x41, 0x41, 0x41, 0x3e}, // O 0x4f 79 52 | {0x7f, 0x09, 0x09, 0x09, 0x06}, // P 0x50 80 53 | {0x3e, 0x41, 0x51, 0x21, 0x5e}, // Q 0x51 81 54 | {0x7f, 0x09, 0x19, 0x29, 0x46}, // R 0x52 82 55 | {0x46, 0x49, 0x49, 0x49, 0x31}, // S 0x53 83 56 | {0x01, 0x01, 0x7f, 0x01, 0x01}, // T 0x54 84 57 | {0x3f, 0x40, 0x40, 0x40, 0x3f}, // U 0x55 85 58 | {0x0f, 0x30, 0x40, 0x30, 0x0f}, // V 0x56 86 59 | {0x3f, 0x40, 0x30, 0x40, 0x3f}, // W 0x57 87 60 | {0x63, 0x14, 0x08, 0x14, 0x63}, // X 0x58 88 61 | {0x07, 0x08, 0x70, 0x08, 0x07}, // Y 0x59 89 62 | {0x61, 0x51, 0x49, 0x45, 0x43}, // Z 0x5a 90 63 | {0x00, 0x00, 0x7f, 0x41, 0x00}, // [ 0x5b 91 64 | {0x02, 0x04, 0x08, 0x10, 0x20}, // \ 0x5c 92 65 | {0x00, 0x41, 0x7f, 0x00, 0x00}, // ] 0x5d 93 66 | {0x04, 0x02, 0x01, 0x02, 0x04}, // ^ 0x5e 94 67 | {0x40, 0x40, 0x40, 0x40, 0x40}, // _ 0x5f 95 68 | {0x00, 0x00, 0x03, 0x04, 0x00}, // ` 0x60 96 69 | {0x20, 0x54, 0x54, 0x54, 0x78}, // a 0x61 97 70 | {0x7f, 0x48, 0x44, 0x44, 0x38}, // b 0x62 98 71 | {0x38, 0x44, 0x44, 0x44, 0x20}, // c 0x63 99 72 | {0x38, 0x44, 0x44, 0x48, 0x7f}, // d 0x64 100 73 | {0x38, 0x54, 0x54, 0x54, 0x18}, // e 0x65 101 74 | {0x08, 0x7e, 0x09, 0x01, 0x02}, // f 0x66 102 75 | {0x0c, 0x52, 0x52, 0x52, 0x3e}, // g 0x67 103 76 | {0x7f, 0x08, 0x04, 0x04, 0x78}, // h 0x68 104 77 | {0x00, 0x44, 0x7d, 0x40, 0x00}, // i 0x69 105 78 | {0x20, 0x40, 0x44, 0x3d, 0x00}, // j 0x6a 106 79 | {0x00, 0x7f, 0x10, 0x28, 0x44}, // k 0x6b 107 80 | {0x00, 0x41, 0x7f, 0x40, 0x00}, // l 0x6c 108 81 | {0x7c, 0x04, 0x18, 0x04, 0x78}, // m 0x6d 109 82 | {0x7c, 0x08, 0x04, 0x04, 0x78}, // n 0x6e 110 83 | {0x38, 0x44, 0x44, 0x44, 0x38}, // o 0x6f 111 84 | {0x7c, 0x14, 0x14, 0x14, 0x08}, // p 0x70 112 85 | {0x08, 0x14, 0x14, 0x18, 0x7c}, // q 0x71 113 86 | {0x7c, 0x08, 0x04, 0x04, 0x08}, // r 0x72 114 87 | {0x48, 0x54, 0x54, 0x54, 0x20}, // s 0x73 115 88 | {0x04, 0x3f, 0x44, 0x40, 0x20}, // t 0x74 116 89 | {0x3c, 0x40, 0x40, 0x20, 0x7c}, // u 0x75 117 90 | {0x1c, 0x20, 0x40, 0x20, 0x1c}, // v 0x76 118 91 | {0x3c, 0x40, 0x30, 0x40, 0x3c}, // w 0x77 119 92 | {0x44, 0x28, 0x10, 0x28, 0x44}, // x 0x78 120 93 | {0x0c, 0x50, 0x50, 0x50, 0x3c}, // y 0x79 121 94 | {0x44, 0x64, 0x54, 0x4c, 0x44}, // z 0x7a 122 95 | {0x00, 0x08, 0x36, 0x41, 0x41}, // { 0x7b 123 96 | {0x00, 0x00, 0x7f, 0x00, 0x00}, // | 0x7c 124 97 | {0x41, 0x41, 0x36, 0x08, 0x00}, // } 0x7d 125 98 | {0x04, 0x02, 0x04, 0x08, 0x04}, // ~ 0x7e 126 99 | 100 | {0x7E, 0x11, 0x11, 0x11, 0x7E}, //__А (0xC0). 101 | {0x7F, 0x49, 0x49, 0x49, 0x33}, //__Б (0xC1). 102 | {0x7F, 0x49, 0x49, 0x49, 0x36}, //__В (0xC2). 103 | {0x7F, 0x01, 0x01, 0x01, 0x03}, //__Г (0xC3). 104 | {0xE0, 0x51, 0x4F, 0x41, 0xFF}, //__Д (0xC4). 105 | {0x7F, 0x49, 0x49, 0x49, 0x41}, //__Е (0xC5). 106 | {0x77, 0x08, 0x7F, 0x08, 0x77}, //__Ж (0xC6). 107 | {0x41, 0x49, 0x49, 0x49, 0x36}, //__З (0xC7). 108 | {0x7F, 0x10, 0x08, 0x04, 0x7F}, //__И (0xC8). 109 | {0x7C, 0x21, 0x12, 0x09, 0x7C}, //__Й (0xC9). 110 | {0x7F, 0x08, 0x14, 0x22, 0x41}, //__К (0xCA). 111 | {0x20, 0x41, 0x3F, 0x01, 0x7F}, //__Л (0xCB). 112 | {0x7F, 0x02, 0x0C, 0x02, 0x7F}, //__М (0xCC). 113 | {0x7F, 0x08, 0x08, 0x08, 0x7F}, //__Н (0xCD). 114 | {0x3E, 0x41, 0x41, 0x41, 0x3E}, //__О (0xCE). 115 | {0x7F, 0x01, 0x01, 0x01, 0x7F}, //__П (0xCF). 116 | {0x7F, 0x09, 0x09, 0x09, 0x06}, //__Р (0xD0). 117 | {0x3E, 0x41, 0x41, 0x41, 0x22}, //__С (0xD1). 118 | {0x01, 0x01, 0x7F, 0x01, 0x01}, //__Т (0xD2). 119 | {0x47, 0x28, 0x10, 0x08, 0x07}, //__У (0xD3). 120 | {0x1C, 0x22, 0x7F, 0x22, 0x1C}, //__Ф (0xD4). 121 | {0x63, 0x14, 0x08, 0x14, 0x63}, //__Х (0xD5). 122 | {0x7F, 0x40, 0x40, 0x40, 0xFF}, //__Ц (0xD6). 123 | {0x07, 0x08, 0x08, 0x08, 0x7F}, //__Ч (0xD7). 124 | {0x7F, 0x40, 0x7F, 0x40, 0x7F}, //__Ш (0xD8). 125 | {0x7F, 0x40, 0x7F, 0x40, 0xFF}, //__Щ (0xD9). 126 | {0x01, 0x7F, 0x48, 0x48, 0x30}, //__Ъ (0xDA). 127 | {0x7F, 0x48, 0x30, 0x00, 0x7F}, //__Ы (0xDB). 128 | {0x00, 0x7F, 0x48, 0x48, 0x30}, //__Ь (0xDC). 129 | {0x22, 0x41, 0x49, 0x49, 0x3E}, //__Э (0xDD). 130 | {0x7F, 0x08, 0x3E, 0x41, 0x3E}, //__Ю (0xDE). 131 | {0x46, 0x29, 0x19, 0x09, 0x7F}, //__Я (0xDF). 132 | 133 | {0x20, 0x54, 0x54, 0x54, 0x78}, //__а (0xE0). 134 | {0x3C, 0x4A, 0x4A, 0x49, 0x31}, //__б (0xE1). 135 | {0x7C, 0x54, 0x54, 0x28, 0x00}, //__в (0xE2). 136 | {0x7C, 0x04, 0x04, 0x0C, 0x00}, //__г (0xE3). 137 | {0xE0, 0x54, 0x4C, 0x44, 0xFC}, //__д (0xE4). 138 | {0x38, 0x54, 0x54, 0x54, 0x18}, //__е (0xE5). 139 | {0x6C, 0x10, 0x7C, 0x10, 0x6C}, //__ж (0xE6). 140 | {0x44, 0x54, 0x54, 0x28, 0x00}, //__з (0xE7). 141 | {0x7C, 0x20, 0x10, 0x08, 0x7C}, //__и (0xE8). 142 | {0x78, 0x42, 0x24, 0x12, 0x78}, //__й (0xE9). 143 | {0x7C, 0x10, 0x28, 0x44, 0x00}, //__к (0xEA). 144 | {0x20, 0x44, 0x3C, 0x04, 0x7C}, //__л (0xEB). 145 | {0x7C, 0x08, 0x10, 0x08, 0x7C}, //__м (0xEC). 146 | {0x7C, 0x10, 0x10, 0x10, 0x7C}, //__н (0xED). 147 | {0x38, 0x44, 0x44, 0x44, 0x38}, //__о (0xEE). 148 | {0x7C, 0x04, 0x04, 0x04, 0x7C}, //__п (0xEF). 149 | {0x7C, 0x14, 0x14, 0x14, 0x08}, //__р (0xF0). 150 | {0x38, 0x44, 0x44, 0x44, 0x00}, //__с (0xF1). 151 | {0x04, 0x04, 0x7C, 0x04, 0x04}, //__т (0xF2). 152 | {0x0C, 0x50, 0x50, 0x50, 0x3C}, //__у (0xF3). 153 | {0x30, 0x48, 0xFE, 0x48, 0x30}, //__ф (0xF4). 154 | {0x44, 0x28, 0x10, 0x28, 0x44}, //__х (0xF5). 155 | {0x7C, 0x40, 0x40, 0x7C, 0xC0}, //__ц (0xF6). 156 | {0x0C, 0x10, 0x10, 0x10, 0x7C}, //__ч (0xF7). 157 | {0x7C, 0x40, 0x7C, 0x40, 0x7C}, //__ш (0xF8). 158 | {0x7C, 0x40, 0x7C, 0x40, 0xFC}, //__щ (0xF9). 159 | {0x04, 0x7C, 0x50, 0x50, 0x20}, //__ъ (0xFA). 160 | {0x7C, 0x50, 0x50, 0x20, 0x7C}, //__ы (0xFB). 161 | {0x7C, 0x50, 0x50, 0x20, 0x00}, //__ь (0xFC). 162 | {0x28, 0x44, 0x54, 0x54, 0x38}, //__э (0xFD). 163 | {0x7C, 0x10, 0x38, 0x44, 0x38}, //__ю (0xFE). 164 | {0x08, 0x54, 0x34, 0x14, 0x7C}, //__я (0xFF). 165 | {0x38, 0x55, 0x54, 0x55, 0x18}, //__ё (0xFF). 166 | /* 167 | {0x7e, 0x09, 0x09, 0x09, 0x7e}, // А 192 168 | {0x7F, 0x49, 0x49, 0x49, 0x71}, // Б 169 | {0x7f, 0x49, 0x49, 0x49, 0x36}, // В 170 | {0x7F, 0x01, 0x01, 0x01, 0x01}, // Г 171 | {0x60, 0x3E, 0x21, 0x3F, 0x60}, // Д 172 | {0x7f, 0x49, 0x49, 0x49, 0x41}, // Е 173 | {0x76, 0x08, 0x7F, 0x08, 0x76}, // Ж 174 | {0x21, 0x41, 0x45, 0x4b, 0x31}, // З 175 | {0x7F, 0x20, 0x10, 0x08, 0x7F}, // И 176 | {0x7E, 0x20, 0x11, 0x08, 0x7E}, // Й 177 | {0x7f, 0x08, 0x14, 0x22, 0x41}, // К 178 | {0x70, 0x0E, 0x01, 0x01, 0x7F}, // Л 179 | {0x7f, 0x02, 0x0c, 0x02, 0x7f}, // М 180 | {0x7f, 0x08, 0x08, 0x08, 0x7f}, // Н 181 | {0x3e, 0x41, 0x41, 0x41, 0x3e}, // О 182 | {0x7F, 0x01, 0x01, 0x01, 0x7F}, // П 183 | {0x7f, 0x09, 0x09, 0x09, 0x06}, // Р 184 | {0x3e, 0x41, 0x41, 0x41, 0x22}, // С 185 | {0x01, 0x01, 0x7f, 0x01, 0x01}, // Т 186 | {0x07, 0x48, 0x48, 0x48, 0x7F}, // У 187 | {0x1C, 0x22, 0x7F, 0x22, 0x1C}, // Ф 188 | {0x63, 0x14, 0x08, 0x14, 0x63}, // Х 189 | {0x7F, 0x40, 0x40, 0x7F, 0xC0}, // Ц 190 | {0x07, 0x08, 0x08, 0x08, 0x7F}, // Ч 191 | {0x7F, 0x40, 0x7F, 0x40, 0x7F}, // Ш 192 | {0x7F, 0x40, 0x7F, 0x40, 0xFF}, // Щ 193 | {0x01, 0x7F, 0x48, 0x48, 0x70}, // Ъ 194 | {0x7F, 0x48, 0x70, 0x00, 0x7F}, // Ы 195 | {0x00, 0x7F, 0x48, 0x48, 0x70}, // Ь 196 | {0x22, 0x41, 0x49, 0x49, 0x3E}, // Э 197 | {0x7F, 0x08, 0x3E, 0x41, 0x3E}, // Ю 198 | {0x46, 0x29, 0x19, 0x09, 0x7F}, // Я 223 199 | 200 | {0x20, 0x54, 0x54, 0x54, 0x78}, //a 224 201 | {0x3c, 0x4a, 0x4a, 0x49, 0x31}, //б 202 | {0x7c, 0x54, 0x54, 0x28, 0x00}, //в 203 | {0x7c, 0x04, 0x04, 0x04, 0x0c}, //г 204 | {0xe0, 0x54, 0x4c, 0x44, 0xfc}, //д 205 | {0x38, 0x54, 0x54, 0x54, 0x18}, //e 206 | {0x6c, 0x10, 0x7c, 0x10, 0x6c}, //ж 207 | {0x44, 0x44, 0x54, 0x54, 0x28}, //з 208 | {0x7c, 0x20, 0x10, 0x08, 0x7c}, //и 209 | {0x7c, 0x41, 0x22, 0x11, 0x7c}, //й 210 | {0x7c, 0x10, 0x28, 0x44, 0x00}, //к 211 | {0x20, 0x44, 0x3c, 0x04, 0x7c}, //л 212 | {0x7c, 0x08, 0x10, 0x08, 0x7c}, //м 213 | {0x7c, 0x10, 0x10, 0x10, 0x7c}, //н 214 | {0x38, 0x44, 0x44, 0x44, 0x38}, //o 215 | {0x7c, 0x04, 0x04, 0x04, 0x7c}, //п 216 | {0x7C, 0x14, 0x14, 0x14, 0x08}, //p 217 | {0x38, 0x44, 0x44, 0x44, 0x20}, //c 218 | {0x04, 0x04, 0x7c, 0x04, 0x04}, //т 219 | {0x0C, 0x50, 0x50, 0x50, 0x3C}, //у 220 | {0x30, 0x48, 0xfc, 0x48, 0x30}, //ф 221 | {0x44, 0x28, 0x10, 0x28, 0x44}, //x 222 | {0x7c, 0x40, 0x40, 0x40, 0xfc}, //ц 223 | {0x0c, 0x10, 0x10, 0x10, 0x7c}, //ч 224 | {0x7c, 0x40, 0x7c, 0x40, 0x7c}, //ш 225 | {0x7c, 0x40, 0x7c, 0x40, 0xfc}, //щ 226 | {0x04, 0x7c, 0x50, 0x50, 0x20}, //ъ 227 | {0x7c, 0x50, 0x50, 0x20, 0x7c}, //ы 228 | {0x7c, 0x50, 0x50, 0x20, 0x00}, //ь 229 | {0x28, 0x44, 0x54, 0x54, 0x38}, //э 230 | {0x7c, 0x10, 0x38, 0x44, 0x38}, //ю 231 | {0x08, 0x54, 0x34, 0x14, 0x7c}, //я 255 232 | */ 233 | }; -------------------------------------------------------------------------------- /README_EN.md: -------------------------------------------------------------------------------- 1 | This is an automatic translation, may be incorrect in some places. See sources and examples! 2 | 3 | # Gyveroled 4 | Light and fast library for OLED display 5 | - Support for OLED display on SSD1306/SSH1106 with a resolution of 128x64 and 128x32 with connection by i2C and SPI 6 | - Choosing a buffer 7 | - at all without a buffer (and without a special loss of possibilities) 8 | - buffer on the side of MK (spends a bunch of RAM, but more convenient in work) 9 | - Boofer update in the selected place (for quick rendering) 10 | - dynamic buffer of the selected size (all geometry, text, bytes) 11 | - Todo: Boofer on the display (only for SSH1106 !!!) 12 | - Conclusion of the text 13 | - The fastest output of the text among OLED Library 14 | - Support for the Russian language and letters e (!) 15 | - A more pleasant font (compared to Beta) 16 | - coordinates outside the display for the possibility of scrolling 17 | - The output of the text to any point (Popixel addressing) 18 | - Full -screen conclusion with the removal of extra gaps 19 | - 4 sizes of letters (based on one font, saves a bunch of memory!) 20 | -the ability to write black and white and white-to-black 21 | - display management 22 | - Installation of brightness 23 | - Fast inversion of the whole display 24 | - turning on/off the display from the sketch 25 | - change in the orientation of the display (mirror vertically and horizontal) 26 | - graphics (contour, filling, cleaning) 27 | - Points 28 | - Lines 29 | - rectangles 30 | - Rectangles with rounded corners 31 | - Circles 32 | - Crooked Bezier 33 | - Images (Bitmap) 34 | - Bitmap output to any display point 35 | - Conclusion "For display" 36 | - There is a program for converting images in the library 37 | - Support for the Microwire library for Atmega328 (very light and quick conclusion) 38 | 39 | ## compatibility 40 | Compatible with all arduino platforms (used arduino functions) 41 | 42 | ## Content 43 | - [installation] (# Install) 44 | - [initialization] (#init) 45 | - [use] (#usage) 46 | - [Example] (# Example) 47 | - [versions] (#varsions) 48 | - [bugs and feedback] (#fedback) 49 | 50 | 51 | ## Installation 52 | - The library can be found by the name ** gyveroled ** and installed through the library manager in: 53 | - Arduino ide 54 | - Arduino ide v2 55 | - Platformio 56 | - [download the library] (https://github.com/gyverlibs/gyveroled/archive/refs/heads/main.zip) .Zip archive for manual installation: 57 | - unpack and put in * C: \ Program Files (X86) \ Arduino \ Libraries * (Windows X64) 58 | - unpack and put in * C: \ Program Files \ Arduino \ Libraries * (Windows X32) 59 | - unpack and put in *documents/arduino/libraries/ * 60 | - (Arduino id) Automatic installation from. Zip: * sketch/connect the library/add .Zip library ... * and specify downloaded archive 61 | - Read more detailed instructions for installing libraries [here] (https://alexgyver.ru/arduino-first/#%D0%A3%D1%81%D1%82%D0%B0%BD%D0%BE%BE%BE%BED0%B2%D0%BA%D0%B0_%D0%B1%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA) 62 | ### Update 63 | - I recommend always updating the library: errors and bugs are corrected in the new versions, as well as optimization and new features are added 64 | - through the IDE library manager: find the library how to install and click "update" 65 | - Manually: ** remove the folder with the old version **, and then put a new one in its place.“Replacement” cannot be done: sometimes in new versions, files that remain when replacing are deleted and can lead to errors! 66 | 67 | 68 | 69 | ## initialCranberries 70 | `` `CPP 71 | // I2C 72 | GyverOLED OLED;// with a buffer 73 | Gyveroled OLED;// without buffer 74 | GyverOLED OLED;// with a buffer 75 | GyverOLED OLED;// without buffer 76 | GyverOLED OLED;// only software buffer 77 | // to the designer you can send the address OLED (0x3c) 78 | 79 | // SPI 80 | Gyveroled OLED; 81 | // where cs, ds, rst - digital pins 82 | // display connects D0 to SCK, D1 to MOSI 83 | 84 | // Note: You can disperse the i2C tire to increase the speed of updating the display.Call 85 | // wire.setclock (800000l); 86 | // after init () initialization of the display 87 | // Note: Not all other i2C modules and sensors will work at such a frequency! 88 | `` ` 89 | 90 | 91 | ## Usage 92 | `` `CPP 93 | // ===== Service ======== 94 | VOID Init ();// Initialization 95 | VOID Init (SDA, SCL);// initialization (you can specify pins i2c for ESP8266/32) 96 | 97 | Void Clear ();// Clean the display 98 | Void Clear (Int X0, Int Y0, Int X1, Int Y1);// Clean the region 99 | VOID setContrast (Uint8_t Value);// brightness 0-255 (silence 127) 100 | VOID setpower (Bool Mode);// on off 101 | VOID FLIPH (Bool Mode);// Reflect horizontally 102 | VOID Invertdisplay (Bool Mode);// Invert the display 103 | Void Flipv (Bool Mode);// Reflect vertically 104 | 105 | // ==== Settings ==== 106 | // Defines before connecting the library 107 | #define oled_no_print // Disable the text output module.Saves ~ 2.5 kb flash 108 | #define oled_spi_Speed // SPI speed 109 | 110 | // ===== Print ======= 111 | // Inherits the Print class, that is, Print/Println any data type 112 | 113 | Void Autoprintln (Bool Mode);// automatically tolerate text 114 | VOID Home ();// Send the cursor at 0.0 115 | VOID setcursor (Int X, Int y);// Put a cursor for the symbol column 0-127, line 0-8 (4) 116 | VOID setcursorxy (int x, int y);// Put a cursor for the symbol column 0-127, pixel 0-63 (31) 117 | VOID Setscale (Uint8_T Scale);// font scale (1-4) 118 | VOID Invertext (Bool Inv);// Invert text (0-1) 119 | Bool Isend ();// Returns True if the display "ends" - with a multiple conclusion 120 | 121 | VOID Textmode (byte mode);// Text drawing mode 122 | BUF_ADD - Add 123 | BUF_SUBTRACT - subtract 124 | Buf_replas - replace 125 | 126 | // ===== graphics ======== 127 | // Next Fill: 128 | Oled_Clear - Clean the area under the figure 129 | Oled_Fill - Pour the figure 130 | Oled_stroke - circle the figure 131 | 132 | VOID DOT (Int X, Int Y, byte Fill);// Point (filling 1/0) 133 | VOID Line (Int X0, Int Y0, Int X1, Int Y1, Byte Fill);// Line (X0, Y0, X1, Y1) 134 | VOID Fastlineh (Int y, Int X0, Int X1, Byte Fill);// horizontal line 135 | VOID FASTLINEV (Int X, Int Y0, Int Y1, Byte Fill);// Vertical line 136 | VOID RECT (Int X0, Int Y0, Int X1, Int Y1, Byte Fill);// rectangle (lion. Verkhn, right. Nizhn) 137 | VOID Roundrect (Int X0, Int Y0, Int X1, Int Y1, Byte Fill);// Rectangle rounded (lion. Verkhn, right. Nizhn) 138 | VOID Circle (Int X, Int y, int radius, byte Fill);// circumference (center x, center U, radius, filling) 139 | VOID Bezier (int* arr, uint8_t size, uint8_t dense, uint8_t fill);// Curve Bezier 140 | 141 | // Bitmap 142 | // invert - bitmap_normal/bitmap_invert invert 143 | // Mode buf_add / buf_subtract / buf_replay 144 | VOID DRAWBITMAP (Int X, Int Y, COST UINT8_T *FRAME, Int width, int Height, Uint8_t Invert = 0, Byte Mode = 0); 145 | 146 | Void Fill (Uint8_t Data);// Pour the entire display specified byte 147 | VOID DRAWBYTE (UINT8_T DATA);// Bait's helmet in the "column" setcursor () and setcursorxy () 148 | VOID DRAWBYTES (UINT8_T* DATA, Byte SIZE);// Bring one -dimensional byte array (linear bitmap 8) 149 | VOID update ();// completely update the display from the buffer 150 | VOID update (int X0, Int Y0, Int X1, Int Y1);// selectively update the display from the buffer (x0, y0, x1, y1) 151 | `` ` 152 | 153 | ### display on SPI + SD card 154 | Famous trouble SD cards http: // ELM-Chan.org/docs/mmc/mmc_e.html, 155 | COSIDERATION ON MULTI-SLAVE Configuration.How to solve: after the completion of communication 156 | With a memory card, you need to release CS cards (the Bibla Bibla is perhaps does it yourself, or let go manually) 157 | And throw a couple of bytes on SPI (a couple of zeros conditionally).Why - the map holds the line of the date. 158 | 159 | 160 | ## Example 161 | The rest of the examples look at ** Examples **! 162 | `` `CPP 163 | // Define before connecting the LIBA - use microWire (Light Liba for i2c) 164 | //# Define use_micro_wire 165 | 166 | // Define before connecting the libe - SPI speed 167 | //# Define OLED_SPI_Speed 4000000UL 168 | 169 | #include 170 | 171 | // Initialization: 172 | // gyveroled OLED; 173 | // "by default" - you can not indicate 174 | 175 | // Model display: 176 | // SSD1306_128X32 177 | // SSD1306_128X64 178 | // ssh1106_128x64 (only with buffer) 179 | 180 | // buffer: 181 | // OLED_NO_BUFFER (without buffer) 182 | // OLED_BUFFER (with a buffer on the MK side) - by default 183 | 184 | // Interface: 185 | // oled_i2c - by default 186 | // oled_spi (specify pins CS, DC, RST/Res) 187 | 188 | // Examples: 189 | // GyverOLED OLED; 190 | // gyveroled OLED; 191 | // GyverOLED OLED; 192 | // gyveroled OLED; 193 | // GyverOLED OLED; 194 | GyverOLED OLED; 195 | 196 | // for i2c you can transmit the address: gyveroled OLED (0x3C); 197 | 198 | // Bitmap created in ImageProcessor https://github.com/alexgyver/imageprocessor 199 | // with the output parameters Vertical byte (OLED) 200 | const uint8_t bitmap_32x32 [] progmem = {{ 201 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xc0, 0xe0, 0xf0, 0x70, 0x70, 0x30, 0x30, 0x30, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xe0, 0xf0, 0xf0,0xf0, 0x70, 0x30, 0x30, 0x20, 0x00, 0x00, 202 | 0x00, 0x30, 0x78, 0xfc, 0x7f, 0x3f, 0x0f, 0x0f, 0x1f, 0x3c, 0x78, 0xf0, 0xe0, 0xc0, 0x80, 0x80, 0x80, 0x40, 0xe0, 0xf0, 0xf8, 0xfc, 0xFF, 0x7f, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x0x13, 0x1e, 0x1c, 0x1c, 0x0e, 0x07, 0x00, 203 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf9, 0xf7, 0XEF, 0x5F, 0x3F, 0x7F, 0XFE, 0xfd, 0xfb, 0xf1, 0xe0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 204 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x1e, 0x33, 0x33, 0x1f, 0x0f, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f0x1f, 0x0e, 0x04, 0x00, 0x00, 0x00, 0x00, 205 | }; 206 | 207 | VOID setup () { 208 | Serial.Begin (9600); 209 | oled.init ();// Initialization 210 | 211 | // ----------------------- 212 | // Speed settings i2c 213 | //Wire.setclock(800000l);// Max.800'000 214 | 215 | // ----------------------- 216 | oled.clear ();// Clean the display (or buffer) 217 | oled.update ();// update.Only for the regime with the buffer!OLED_BUFFER 218 | 219 | // ----------------------- 220 | oled.home ();// Cursor at 0.0 221 | oled.print ("Hello!");// Print anything: numbers, lines, float, like serial! 222 | oled.update (); 223 | DELAY (2000); 224 | 225 | // ----------------------- 226 | oled.Setcursor (5, 1);// cursor in (pixel x, line y) 227 | oled.Setscale (2); 228 | oled.print ("Hello!"); 229 | oled.update (); 230 | DELAY (2000); 231 | 232 | // ----------------------- 233 | oled.setcursorxy (15, 30);// cursor in (pixel x, pixel y) 234 | oled.Setscale (3); 235 | oled.invertext (True);// Invert the text! 236 | oled.print ("Hello!"); 237 | oled.update (); 238 | DELAY (2000); 239 | 240 | // ----------------------- 241 | oled.clear (); 242 | oled.home (); 243 | oled.setscale (1); 244 | oled.invertext (false); 245 | oled.autoprintln (True);// automatically tolerate text 246 | oled.print (f ("lorem ipsum dolor site amet, flamier ipsum sit amet Hello people ё, Consectur Adipiscing Elit, Sed Do -eiusmod Tempor IncidIDIDIDUNT UT DOLORE MAGNA ALIIKA. D minim Veniam ")); 247 | oled.update (); 248 | DELAY (2000); 249 | 250 | // ----------------------- 251 | oled.home (); 252 | oled.textmode (buf_add); 253 | // buf_add - impose a text 254 | // buf_subtract - subtract text 255 | // buf_replas - replace (the entire rectangle of the letter) 256 | oled.home (); 257 | oled.Setscale (3); 258 | oled.print ("Kek!"); 259 | oled.update (); 260 | DELAY (2000); 261 | 262 | // ----------------------- 263 | // SERVICE 264 | //OLED.SETCONTRAST (10);// brightness 0..15 265 | //OLED.SetPower(True);// True/false - turn on/off the display 266 | //OLED.FLIPH(True);// True/false - wink horizontally 267 | //OLED.FLIPV(True);// True/false - wiring vertically 268 | //OLED.Send ();// Returns True if the display "ends" - with a multiple conclusion 269 | 270 | // ----------------------- 271 | oled.clear (); 272 | oled.dot (0, 0);// Point on X, Y 273 | oled.dot (0, 1, 1);// Third Argument: 0 Off Pixel, 1 ON PIXEL (SITION) 274 | oled.line (5, 5, 10, 10);// Line X0, Y0, X1, Y1 275 | //OLED.LINE (5, 5, 10, 10, 0);// Fifth argument: 0 erase, 1 draw (by the silence) 276 | oled.fastlineh (0, 5, 10);// horizontal line (y, x1, x2) 277 | //OLED.FASTLINEH, 5, 10, 0);// Fourth argument: 0 erase, 1 draw (by the silence) 278 | oled.fastlinev (0, 5, 10);// Similarly, vert.Line (X, Y1, Y2) 279 | oled.rect (20, 20, 30, 25);// rectangle (x0, y0, x1, y1) 280 | oled.rect (5, 35, 35, 60, oled_stroke);// rectangle (x0, y0, x1, y1) 281 | // Figure Parameters: 282 | // OLED_Clear - Clear 283 | // oled_fill - pour 284 | // oled_stroke - draw a frame 285 | oled.roundrect (50, 5, 80, 25, Oled_stroke);// similarly a rounded rectangle 286 | oled.circle (60, 45, 15, oled_stroke);// circumference with center B (x, y, with radius) 287 | oled.circle (60, 45, 5, oled_fill);// Fourth argument: figure parameter 288 | 289 | // Bitmap 290 | oled.drawbitmap (90, 16, Bitmap_32x32, 32, 32, Bitmap_normal, Buf_add); 291 | //OLELD.DRAWBITMAP (90, 16, bitmap_32x32, 32, 32);// by the silence.Normal and buf_add 292 | // x, y, name, width, height, bitmap_normal (0)/bitmap_invert (1), buf_add/buf_subtract/buf_replay 293 | 294 | oled.update (); 295 | } 296 | 297 | VOID loop () { 298 | } 299 | `` ` 300 | 301 | 302 | ## versions 303 | - v0.1 (02.27.2021) - corrected the unprintable lower line 304 | - v0.2 (03/16/2021) - Fixed symbols [|] ~ $ 305 | - v0.3 (03/26/2021) - added Curve Bezier 306 | - v0.4 (10.04.2021) - compatibility with ESP 307 | - V0.5 (05.05.2021) - Support SPI and SSH1106 (only buffer) added!GND-VCC-SCK-DATA-RST-DC-CS 308 | 309 | - v1.0 - release 310 | - V1.1 - improved the transfer of lines (does not remove the first symbol just like that) 311 | - V1.2 - Redeled Fastio 312 | - v1.3 - rectangles can be drawn from any corner 313 | - v1.3.1 - fixed the lines (broke in 1.3.0) 314 | - v1.3.2 - removed Fastio 315 | - V1.4 - Spi displays Faced 316 | - v1.5 - a broken conclusion after cleaning without specifying the cursor 317 | - V1.6 - The choice of I2C Pin for ESPX has been added, Clear (..) for buffer, added the ability to disable the text module 318 | - V1.6.1 - re -release for the library manager 319 | 320 | 321 | ## bugs and feedback 322 | Create ** Issue ** when you find the bugs, and better immediately write to the mail [alex@alexgyver.ru] (mailto: alex@alexgyver.ru) 323 | The library is open for refinement and your ** pull Request ** 'ow! 324 | 325 | 326 | When reporting about bugs or incorrect work of the library, it is necessary to indicate: 327 | - The version of the library 328 | - What is MK used 329 | - SDK version (for ESP) 330 | - version of Arduino ide 331 | - whether the built -in examples work correctly, in which the functions and designs are used, leading to a bug in your code 332 | - what code has been loaded, what work was expected from it and how it works in reality 333 | - Ideally, attach the minimum code in which the bug is observed.Not a canvas of a thousand lines, but a minimum code -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![latest](https://img.shields.io/github/v/release/GyverLibs/GyverOLED.svg?color=brightgreen)](https://github.com/GyverLibs/GyverOLED/releases/latest/download/GyverOLED.zip) 2 | [![PIO](https://badges.registry.platformio.org/packages/gyverlibs/library/GyverOLED.svg)](https://registry.platformio.org/libraries/gyverlibs/GyverOLED) 3 | [![Foo](https://img.shields.io/badge/Website-AlexGyver.ru-blue.svg?style=flat-square)](https://alexgyver.ru/) 4 | [![Foo](https://img.shields.io/badge/%E2%82%BD%24%E2%82%AC%20%D0%9F%D0%BE%D0%B4%D0%B4%D0%B5%D1%80%D0%B6%D0%B0%D1%82%D1%8C-%D0%B0%D0%B2%D1%82%D0%BE%D1%80%D0%B0-orange.svg?style=flat-square)](https://alexgyver.ru/support_alex/) 5 | [![Foo](https://img.shields.io/badge/README-ENGLISH-blueviolet.svg?style=flat-square)](https://github-com.translate.goog/GyverLibs/GyverOLED?_x_tr_sl=ru&_x_tr_tl=en) 6 | 7 | [![Foo](https://img.shields.io/badge/ПОДПИСАТЬСЯ-НА%20ОБНОВЛЕНИЯ-brightgreen.svg?style=social&logo=telegram&color=blue)](https://t.me/GyverLibs) 8 | 9 | # GyverOLED 10 | Лёгкая и быстрая библиотека для OLED дисплея 11 | - Поддержка OLED дисплеев на SSD1306/SSH1106 с разрешением 128х64 и 128х32 с подключением по I2C и SPI 12 | - Выбор буфера 13 | - Вообще без буфера (и без особой потери возможностей) 14 | - Буфер на стороне МК (тратит кучу оперативки, но удобнее в работе) 15 | - Обновление буфера в выбранном месте (для быстрой отрисовки) 16 | - Динамический буфер выбранного размера (вся геометрия, текст, байты) 17 | - TODO: Буфер на стороне дисплея (только для SSH1106!!!) 18 | - Вывод текста 19 | - Самый быстрый вывод текста среди OLED библиотек 20 | - Поддержка русского языка и буквы ё (!) 21 | - Более приятный шрифт (по сравнению с beta) 22 | - Координаты вне дисплея для возможности прокрутки 23 | - Вывод текста в любую точку (попиксельная адресация) 24 | - Полноэкранный вывод с удалением лишних пробелов 25 | - 4 размера букв (на базе одного шрифта, экономит кучу памяти!) 26 | - Возможность писать чёрным-по-белому и белым-по-чёрному 27 | - Управление дисплеем 28 | - Установка яркости 29 | - Быстрая инверсия всего дисплея 30 | - Включение/выключение дисплея из скетча 31 | - Изменение ориентации дисплея (зеркально по вертикали и горизонтали) 32 | - Графика (контур, заливка, очистка) 33 | - Точки 34 | - Линии 35 | - Прямоугольники 36 | - Прямоугольники со скруглёнными углами 37 | - Окружности 38 | - Кривые Безье 39 | - Изображения (битмап) 40 | - Вывод битмапа в любую точку дисплея 41 | - Вывод "за дисплей" 42 | - Программа для конвертации изображений есть в библиотеке 43 | - Поддержка библиотеки microWire для ATmega328 (очень лёгкий и быстрый вывод) 44 | 45 | ### Совместимость 46 | Совместима со всеми Arduino платформами (используются Arduino-функции) 47 | 48 | ## Содержание 49 | - [Установка](#install) 50 | - [Инициализация](#init) 51 | - [Использование](#usage) 52 | - [Пример](#example) 53 | - [Версии](#versions) 54 | - [Баги и обратная связь](#feedback) 55 | 56 | 57 | ## Установка 58 | - Библиотеку можно найти по названию **GyverOLED** и установить через менеджер библиотек в: 59 | - Arduino IDE 60 | - Arduino IDE v2 61 | - PlatformIO 62 | - [Скачать библиотеку](https://github.com/GyverLibs/GyverOLED/archive/refs/heads/main.zip) .zip архивом для ручной установки: 63 | - Распаковать и положить в *C:\Program Files (x86)\Arduino\libraries* (Windows x64) 64 | - Распаковать и положить в *C:\Program Files\Arduino\libraries* (Windows x32) 65 | - Распаковать и положить в *Документы/Arduino/libraries/* 66 | - (Arduino IDE) автоматическая установка из .zip: *Скетч/Подключить библиотеку/Добавить .ZIP библиотеку…* и указать скачанный архив 67 | - Читай более подробную инструкцию по установке библиотек [здесь](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) 68 | ### Обновление 69 | - Рекомендую всегда обновлять библиотеку: в новых версиях исправляются ошибки и баги, а также проводится оптимизация и добавляются новые фичи 70 | - Через менеджер библиотек IDE: найти библиотеку как при установке и нажать "Обновить" 71 | - Вручную: **удалить папку со старой версией**, а затем положить на её место новую. "Замену" делать нельзя: иногда в новых версиях удаляются файлы, которые останутся при замене и могут привести к ошибкам! 72 | 73 | 74 | 75 | ## Инициализация 76 | ```cpp 77 | // I2C 78 | GyverOLED oled; // с буфером 79 | GyverOLED oled; // без буфера 80 | GyverOLED oled; // с буфером 81 | GyverOLED oled; // без буфера 82 | GyverOLED oled; // только программный буфер 83 | // конструктору можно передать адрес oled(0x3C) 84 | 85 | // SPI 86 | GyverOLED oled; 87 | // где CS, DS, RST - цифровые пины 88 | // дисплей подключается D0 к SCK, D1 к MOSI 89 | 90 | // примечание: можно разогнать шину i2c для увеличения скорости обновления дисплея. Вызвать 91 | // Wire.setClock(800000L); 92 | // после init() инициализации дисплея 93 | // примечание: не все другие i2c модули и датчики будут работать на такой частоте! 94 | ``` 95 | 96 | 97 | ## Использование 98 | ```cpp 99 | // ===== СЕРВИС ===== 100 | void init(); // инициализация 101 | void init(sda, scl); // инициализация (можно указать пины i2c для esp8266/32) 102 | 103 | void clear(); // очистить дисплей 104 | void clear(int x0, int y0, int x1, int y1); // очистить область 105 | void setContrast(uint8_t value); // яркость 0-255 (умолч. 127) 106 | void setPower(bool mode); // вкл/выкл 107 | void flipH(bool mode); // отразить по горизонтали 108 | void invertDisplay(bool mode); // инвертировать дисплей 109 | void flipV(bool mode); // отразить по вертикали 110 | 111 | // ==== НАСТРОЙКИ === 112 | // дефайны ПЕРЕД подключением библиотеки 113 | #define OLED_NO_PRINT // отключить модуль вывода текста. Экономит ~2.5 кБ Flash 114 | #define OLED_SPI_SPEED // скорость SPI 115 | 116 | // ===== ПЕЧАТЬ ===== 117 | // наследует класс Print, то есть print/println любой тип данных 118 | 119 | void autoPrintln(bool mode); // автоматически переносить текст 120 | void home(); // отправить курсор в 0,0 121 | void setCursor(int x, int y); // поставить курсор для символа столбец 0-127, строка 0-8(4) 122 | void setCursorXY(int x, int y); // поставить курсор для символа столбец 0-127, пиксель 0-63(31) 123 | void setScale(uint8_t scale); // масштаб шрифта (1-4) 124 | void invertText(bool inv); // инвертировать текст (0-1) 125 | bool isEnd(); // возвращает true, если дисплей "кончился" - при побуквенном выводе 126 | 127 | void textMode(byte mode); // режим отрисовки текста 128 | BUF_ADD - добавить 129 | BUF_SUBTRACT - вычесть 130 | BUF_REPLACE - заменить 131 | 132 | // ===== ГРАФИКА ===== 133 | // далее fill: 134 | OLED_CLEAR - очистить область под фигурой 135 | OLED_FILL - залить фигуру 136 | OLED_STROKE - обвести фигуру 137 | 138 | void dot(int x, int y, byte fill); // точка (заливка 1/0) 139 | void line(int x0, int y0, int x1, int y1, byte fill); // линия (x0, y0, x1, y1) 140 | void fastLineH(int y, int x0, int x1, byte fill); // горизонтальная линия 141 | void fastLineV(int x, int y0, int y1, byte fill); // вертикальная линия 142 | void rect(int x0, int y0, int x1, int y1, byte fill); // прямоугольник (лев. верхн, прав. нижн) 143 | void roundRect(int x0, int y0, int x1, int y1, byte fill); // прямоугольник скруглённый (лев. верхн, прав. нижн) 144 | void circle(int x, int y, int radius, byte fill); // окружность (центр х, центр у, радиус, заливка) 145 | void bezier(int* arr, uint8_t size, uint8_t dense, uint8_t fill); // кривая Безье 146 | 147 | // вывести битмап 148 | // invert - BITMAP_NORMAL/BITMAP_INVERT инвертировать 149 | // mode BUF_ADD / BUF_SUBTRACT / BUF_REPLACE 150 | void drawBitmap(int x, int y, const uint8_t *frame, int width, int height, uint8_t invert = 0, byte mode = 0); 151 | 152 | void fill(uint8_t data); // залить весь дисплей указанным байтом 153 | void drawByte(uint8_t data); // шлёт байт в "столбик" setCursor() и setCursorXY() 154 | void drawBytes(uint8_t* data, byte size); // вывести одномерный байтовый массив (линейный битмап высотой 8) 155 | void update(); // полностью обновить дисплей из буфера 156 | void update(int x0, int y0, int x1, int y1); // выборочно обновить дисплей из буфера (x0, y0, x1, y1) 157 | ``` 158 | 159 | ### Дисплей по SPI + SD карта 160 | известная беда SD карт http://elm-chan.org/docs/mmc/mmc_e.html, 161 | пункт Cosideration on Multi-slave Configuration. Как решить: после завершения общения 162 | с картой памяти нужно отпустить CS карты (библа SD возможно сама это делает, либо отпустить вручную) 163 | и закинуть по SPI пару байт (пару нулей условно). Почему - карта держит линию даты. 164 | 165 | 166 | ## Пример 167 | Остальные примеры смотри в **examples**! 168 | ```cpp 169 | // дефайн перед подключением либы - использовать microWire (лёгкая либа для I2C) 170 | //#define USE_MICRO_WIRE 171 | 172 | // дефайн перед подключением либы - скорость SPI 173 | //#define OLED_SPI_SPEED 4000000ul 174 | 175 | #include 176 | 177 | // инициализация: 178 | // GyverOLED<модель, буфер, интерфейс, CS, DC, RST> oled; 179 | // "по умолчанию" - можно не указывать 180 | 181 | // модель дисплея: 182 | // SSD1306_128x32 183 | // SSD1306_128x64 184 | // SSH1106_128x64 (ТОЛЬКО С БУФЕРОМ) 185 | 186 | // буфер: 187 | // OLED_NO_BUFFER (без буфера) 188 | // OLED_BUFFER (с буфером на стороне МК) - по умолчанию 189 | 190 | // интерфейс: 191 | // OLED_I2C - по умолчанию 192 | // OLED_SPI (указать пины CS, DC, RST/RES) 193 | 194 | // примеры: 195 | //GyverOLED oled; 196 | //GyverOLED oled; 197 | //GyverOLED oled; 198 | //GyverOLED oled; 199 | //GyverOLED oled; 200 | GyverOLED oled; 201 | 202 | // для I2C можно передать адрес: GyverOLED oled(0x3C); 203 | 204 | // битмап создан в ImageProcessor https://github.com/AlexGyver/imageProcessor 205 | // с параметрами вывода vertical byte (OLED) 206 | const uint8_t bitmap_32x32[] PROGMEM = { 207 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xC0, 0xE0, 0xF0, 0x70, 0x70, 0x30, 0x30, 0x30, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF0, 0x70, 0x30, 0x30, 0x20, 0x00, 0x00, 208 | 0x00, 0x30, 0x78, 0xFC, 0x7F, 0x3F, 0x0F, 0x0F, 0x1F, 0x3C, 0x78, 0xF0, 0xE0, 0xC0, 0x80, 0x80, 0x80, 0x40, 0xE0, 0xF0, 0xF8, 0xFC, 0xFF, 0x7F, 0x33, 0x13, 0x1E, 0x1C, 0x1C, 0x0E, 0x07, 0x00, 209 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF9, 0xF7, 0xEF, 0x5F, 0x3F, 0x7F, 0xFE, 0xFD, 0xFB, 0xF1, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 210 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x1E, 0x33, 0x33, 0x1F, 0x0F, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x1F, 0x0E, 0x04, 0x00, 0x00, 0x00, 0x00, 211 | }; 212 | 213 | void setup() { 214 | Serial.begin(9600); 215 | oled.init(); // инициализация 216 | 217 | // -------------------------- 218 | // настройка скорости I2C 219 | //Wire.setClock(800000L); // макс. 800'000 220 | 221 | // -------------------------- 222 | oled.clear(); // очистить дисплей (или буфер) 223 | oled.update(); // обновить. Только для режима с буфером! OLED_BUFFER 224 | 225 | // -------------------------- 226 | oled.home(); // курсор в 0,0 227 | oled.print("Hello!"); // печатай что угодно: числа, строки, float, как Serial! 228 | oled.update(); 229 | delay(2000); 230 | 231 | // -------------------------- 232 | oled.setCursor(5, 1); // курсор в (пиксель X, строка Y) 233 | oled.setScale(2); 234 | oled.print("Hello!"); 235 | oled.update(); 236 | delay(2000); 237 | 238 | // -------------------------- 239 | oled.setCursorXY(15, 30); // курсор в (пиксель X, пиксель Y) 240 | oled.setScale(3); 241 | oled.invertText(true); // инвертируй текст! 242 | oled.print("Привет!"); 243 | oled.update(); 244 | delay(2000); 245 | 246 | // -------------------------- 247 | oled.clear(); 248 | oled.home(); 249 | oled.setScale(1); 250 | oled.invertText(false); 251 | oled.autoPrintln(true); // автоматически переносить текст 252 | oled.print(F("Lorem ipsum dolor sit amet, лорем ипсум долор сит амет привет народ ё, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam")); 253 | oled.update(); 254 | delay(2000); 255 | 256 | // -------------------------- 257 | oled.home(); 258 | oled.textMode(BUF_ADD); 259 | // BUF_ADD - наложить текст 260 | // BUF_SUBTRACT - вычесть текст 261 | // BUF_REPLACE - заменить (весь прямоугольник буквы) 262 | oled.home(); 263 | oled.setScale(3); 264 | oled.print("KEK!"); 265 | oled.update(); 266 | delay(2000); 267 | 268 | // -------------------------- 269 | // СЕРВИС 270 | //oled.setContrast(10); // яркость 0..15 271 | //oled.setPower(true); // true/false - включить/выключить дисплей 272 | //oled.flipH(true); // true/false - отзеркалить по горизонтали 273 | //oled.flipV(true); // true/false - отзеркалить по вертикали 274 | //oled.isEnd(); // возвращает true, если дисплей "кончился" - при побуквенном выводе 275 | 276 | // -------------------------- 277 | oled.clear(); 278 | oled.dot(0, 0); // точка на x,y 279 | oled.dot(0, 1, 1); // третий аргумент: 0 выкл пиксель, 1 вкл пиксель (по умолч) 280 | oled.line(5, 5, 10, 10); // линия x0,y0,x1,y1 281 | //oled.line(5, 5, 10, 10, 0); // пятый аргумент: 0 стереть, 1 нарисовать (по умолч) 282 | oled.fastLineH(0, 5, 10); // горизонтальная линия (y, x1, x2) 283 | //oled.fastLineH(0, 5, 10, 0); // четвёртый аргумент: 0 стереть, 1 нарисовать (по умолч) 284 | oled.fastLineV(0, 5, 10); // аналогично верт. линия (x, y1, y2) 285 | oled.rect(20, 20, 30, 25); // прямоугольник (x0,y0,x1,y1) 286 | oled.rect(5, 35, 35, 60, OLED_STROKE); // прямоугольник (x0,y0,x1,y1) 287 | // параметры фигуры: 288 | // OLED_CLEAR - очистить 289 | // OLED_FILL - залить 290 | // OLED_STROKE - нарисовать рамку 291 | oled.roundRect(50, 5, 80, 25, OLED_STROKE); // аналогично скруглённый прямоугольник 292 | oled.circle(60, 45, 15, OLED_STROKE); // окружность с центром в (x,y, с радиусом) 293 | oled.circle(60, 45, 5, OLED_FILL); // четвёртый аргумент: параметр фигуры 294 | 295 | // битмап 296 | oled.drawBitmap(90, 16, bitmap_32x32, 32, 32, BITMAP_NORMAL, BUF_ADD); 297 | //oled.drawBitmap(90, 16, bitmap_32x32, 32, 32); // по умолч. нормал и BUF_ADD 298 | // x, y, имя, ширина, высота, BITMAP_NORMAL(0)/BITMAP_INVERT(1), BUF_ADD/BUF_SUBTRACT/BUF_REPLACE 299 | 300 | oled.update(); 301 | } 302 | 303 | void loop() { 304 | } 305 | ``` 306 | 307 | 308 | ## Версии 309 | - v0.1 (27.02.2021) - исправил непечатающуюся нижнюю строку 310 | - v0.2 (16.03.2021) - исправлены символы [|]~$ 311 | - v0.3 (26.03.2021) - добавил кривую Безье 312 | - v0.4 (10.04.2021) - совместимость с есп 313 | - v0.5 (09.05.2021) - добавлена поддержка SPI и SSH1106 (только буфер)! gnd-vcc-sck-data-rst-dc-cs 314 | 315 | - v1.0 - релиз 316 | - v1.1 - улучшен перенос строк (не убирает первый символ просто так) 317 | - v1.2 - переделан FastIO 318 | - v1.3 - прямоугольники можно рисовать из любого угла 319 | - v1.3.1 - пофиксил линии (сломались в 1.3.0) 320 | - v1.3.2 - убран FastIO 321 | - v1.4 - пофикшены SPI дисплеи 322 | - v1.5 - пофикшен битый вывод после очистки без указания курсора 323 | - v1.6 - добавлен выбор пинов I2C для espX, исправлен clear(..) для BUFFER, добавлена возможность отключить модуль текста 324 | - v1.6.1 - повторный релиз для менеджера библиотек 325 | 326 | 327 | ## Баги и обратная связь 328 | При нахождении багов создавайте **Issue**, а лучше сразу пишите на почту [alex@alexgyver.ru](mailto:alex@alexgyver.ru) 329 | Библиотека открыта для доработки и ваших **Pull Request**'ов! 330 | 331 | 332 | При сообщении о багах или некорректной работе библиотеки нужно обязательно указывать: 333 | - Версия библиотеки 334 | - Какой используется МК 335 | - Версия SDK (для ESP) 336 | - Версия Arduino IDE 337 | - Корректно ли работают ли встроенные примеры, в которых используются функции и конструкции, приводящие к багу в вашем коде 338 | - Какой код загружался, какая работа от него ожидалась и как он работает в реальности 339 | - В идеале приложить минимальный код, в котором наблюдается баг. Не полотно из тысячи строк, а минимальный код 340 | -------------------------------------------------------------------------------- /icons/iconsVisualiser/iconsVisualiser.pde: -------------------------------------------------------------------------------- 1 | int icons_7x7[][] = { 2 | {0x7f, 0x45, 0x49, 0x51, 0x49, 0x45, 0x7f}, //0 email 3 | {0x3e, 0x6f, 0x51, 0x01, 0x71, 0x7f, 0x3e}, //1 github 4 | {0x40, 0x60, 0x77, 0x77, 0x77, 0x60, 0x40}, //2 user 5 | {0x70, 0x7e, 0x71, 0x51, 0x71, 0x7e, 0x70}, //3 lock, password 6 | {0x08, 0x3e, 0x36, 0x63, 0x36, 0x3e, 0x08}, //4 cog, settings 7 | {0x3e, 0x63, 0x41, 0x4d, 0x49, 0x63, 0x3e}, //5 clock 8 | {0x0e, 0x11, 0x11, 0x11, 0x3e, 0x60, 0x40}, //6 search 9 | {0x7e, 0x3f, 0x15, 0x15, 0x1d, 0x1f, 0x0e}, //7 message 10 | {0x00, 0x22, 0x14, 0x7f, 0x49, 0x36, 0x00}, //8 bluetooth 11 | {0x1c, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e}, //9 battery 100% 12 | {0x1c, 0x3e, 0x22, 0x3e, 0x3e, 0x3e, 0x3e}, //10 battery 75% 13 | {0x1c, 0x3e, 0x22, 0x22, 0x3e, 0x3e, 0x3e}, //11 battery 50% 14 | {0x1c, 0x3e, 0x22, 0x22, 0x22, 0x3e, 0x3e}, //12 battery 25% 15 | {0x1c, 0x3e, 0x22, 0x22, 0x22, 0x22, 0x3e}, //13 battery 0% 16 | {0x77, 0x41, 0x41, 0x00, 0x41, 0x41, 0x77}, //14 full screen 17 | {0x22, 0x63, 0x00, 0x00, 0x00, 0x63, 0x22}, //15 small screen 18 | {0x02, 0x7a, 0x4b, 0x7b, 0x4b, 0x7a, 0x02}, //16 trash, remove, delete 19 | {0x3c, 0x42, 0x43, 0x52, 0x53, 0x42, 0x3c}, //17 calendar 20 | {0x3e, 0x41, 0x5d, 0x58, 0x54, 0x42, 0x31}, //18 minimize 21 | {0x3e, 0x41, 0x41, 0x48, 0x45, 0x43, 0x37}, //19 maximize 22 | {0x3c, 0x24, 0x77, 0x55, 0x77, 0x24, 0x3c}, //20 printer 23 | {0x1c, 0x1c, 0x1c, 0x22, 0x77, 0x77, 0x77}, //21 share 24 | {0x0c, 0x1e, 0x3b, 0x71, 0x3b, 0x1e, 0x0c}, //22 map 25 | {0x6c, 0x47, 0x6d, 0x6d, 0x6d, 0x47, 0x6c}, //23 case 26 | {0x70, 0x7c, 0x7e, 0x53, 0x7e, 0x7c, 0x70}, //24 warning 27 | {0x1c, 0x3e, 0x77, 0x77, 0x77, 0x3e, 0x1c}, //25 error 28 | {0x3e, 0x41, 0x5d, 0x5d, 0x5d, 0x41, 0x3e}, //26 record 29 | {0x7f, 0x7f, 0x3e, 0x3e, 0x1c, 0x1c, 0x08}, //27 play 30 | {0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f}, //28 stop 31 | {0x00, 0x7f, 0x7f, 0x00, 0x7f, 0x7f, 0x00}, //29 pause 32 | {0x7f, 0x3e, 0x1c, 0x00, 0x7f, 0x3e, 0x1c}, //30 forward 33 | {0x1c, 0x3e, 0x7f, 0x00, 0x1c, 0x3e, 0x7f}, //31 backward 34 | {0x03, 0x07, 0x0f, 0x7f, 0x0f, 0x07, 0x03}, //32 filter 35 | {0x03, 0x05, 0x09, 0x71, 0x09, 0x05, 0x03}, //33 filter out 36 | {0x1c, 0x3e, 0x7f, 0x00, 0x08, 0x22, 0x1c}, //34 sound 100% 37 | {0x1c, 0x3e, 0x7f, 0x00, 0x1c, 0x00, 0x00}, //35 sound 50% 38 | {0x1c, 0x3e, 0x7f, 0x00, 0x00, 0x00, 0x00}, //36 sound 0% 39 | {0x01, 0x02, 0x1c, 0x3e, 0x7f, 0x20, 0x40}, //37 sound off 40 | {0x70, 0x44, 0x48, 0x5f, 0x48, 0x44, 0x70}, //38 download 41 | {0x70, 0x44, 0x42, 0x5f, 0x42, 0x44, 0x70}, //39 upload 42 | {0x3e, 0x41, 0x41, 0x4f, 0x49, 0x4a, 0x3c}, //40 text upload 43 | {0x70, 0x48, 0x50, 0x2a, 0x05, 0x09, 0x07}, //41 link 44 | {0x70, 0x48, 0x44, 0x26, 0x19, 0x0a, 0x04}, //42 pencil 45 | {0x7e, 0x3f, 0x1f, 0x0f, 0x1f, 0x3f, 0x7e}, //43 bookmark 46 | {0x08, 0x4c, 0x6e, 0x7f, 0x3b, 0x19, 0x08}, //44 flash, lighting 47 | {0x3e, 0x41, 0x49, 0x55, 0x55, 0x51, 0x4e}, //45 attach 48 | {0x0e, 0x1f, 0x3e, 0x7c, 0x3e, 0x1f, 0x0e}, //46 heart 49 | {0x0e, 0x11, 0x22, 0x44, 0x22, 0x11, 0x0e}, //47 heart out 50 | {0x32, 0x33, 0x33, 0x7f, 0x33, 0x33, 0x23}, //48 direction 51 | {0x08, 0x14, 0x22, 0x2a, 0x22, 0x14, 0x08}, //49 eye, visible 52 | {0x02, 0x05, 0x09, 0x7f, 0x09, 0x05, 0x02}, //50 antenna 53 | {0x60, 0x00, 0x70, 0x00, 0x7c, 0x00, 0x7f}, //51 mobile network 100% 54 | {0x60, 0x00, 0x70, 0x00, 0x7c, 0x00, 0x40}, //52 mobile network 75% 55 | {0x60, 0x00, 0x70, 0x00, 0x40, 0x00, 0x40}, //53 mobile network 50% 56 | {0x60, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40}, //54 mobile network 25% 57 | {0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40}, //55 mobile network 0% 58 | {0x10, 0x20, 0x7f, 0x00, 0x7f, 0x02, 0x04}, //56 sync 59 | {0x3e, 0x3e, 0x3e, 0x1c, 0x08, 0x1c, 0x3e}, //57 video 60 | {0x02, 0x09, 0x25, 0x15, 0x25, 0x09, 0x02}, //58 wifi 61 | {0x38, 0x44, 0x42, 0x52, 0x4c, 0x48, 0x30}, //59 cloud 62 | {0x01, 0x0a, 0x78, 0x7b, 0x78, 0x0a, 0x01}, //60 flashlight on 63 | {0x00, 0x08, 0x78, 0x48, 0x78, 0x08, 0x00}, //61 flashlight off 64 | {0x38, 0x26, 0x61, 0x61, 0x61, 0x26, 0x38}, //62 bell 65 | {0x70, 0x7e, 0x71, 0x51, 0x71, 0x72, 0x70}, //63 unlock 66 | {0x1c, 0x00, 0x7f, 0x41, 0x7f, 0x00, 0x1c}, //64 vibrate 67 | {0x3e, 0x41, 0x49, 0x51, 0x49, 0x44, 0x32}, //65 checked 68 | {0x3e, 0x41, 0x41, 0x41, 0x41, 0x41, 0x3e}, //66 unchecked 69 | {0x2a, 0x00, 0x7f, 0x41, 0x7f, 0x00, 0x2a}, //67 chip 70 | {0x28, 0x28, 0x7d, 0x42, 0x7d, 0x28, 0x28}, //68 bug 71 | {0x7f, 0x49, 0x69, 0x69, 0x69, 0x4a, 0x7c}, //69 save 72 | {0x7e, 0x52, 0x4a, 0x4a, 0x6c, 0x18, 0x08}, //70 open 73 | {0x60, 0x70, 0x3e, 0x19, 0x11, 0x10, 0x0c}, //71 tool 74 | {0x7f, 0x75, 0x5b, 0x5f, 0x5f, 0x5f, 0x7f}, //72 console 75 | {0x49, 0x49, 0x00, 0x49, 0x49, 0x49, 0x49}, //73 todo, list 76 | {0x77, 0x77, 0x77, 0x00, 0x72, 0x77, 0x72}, //74 apps 77 | {0x71, 0x4a, 0x64, 0x44, 0x64, 0x4a, 0x71}, //75 android 78 | {0x00, 0x06, 0x39, 0x51, 0x39, 0x06, 0x00}, //76 bulb 79 | {0x3e, 0x41, 0x49, 0x08, 0x2a, 0x1c, 0x08}, //77 logout 80 | {0x08, 0x2a, 0x1c, 0x49, 0x41, 0x41, 0x3e}, //78 login 81 | {0x3e, 0x41, 0x49, 0x5d, 0x49, 0x61, 0x7e}, //79 zoom in 82 | {0x3e, 0x41, 0x49, 0x49, 0x69, 0x71, 0x7e}, //80 zoom out 83 | {0x7f, 0x7f, 0x7f, 0x00, 0x77, 0x77, 0x77}, //81 dashboard 84 | {0x63, 0x49, 0x1c, 0x3e, 0x1c, 0x49, 0x63}, //82 all out 85 | {0x60, 0x70, 0x79, 0x7f, 0x79, 0x70, 0x60}, //83 science 86 | {0x1c, 0x22, 0x51, 0x49, 0x45, 0x22, 0x1c}, //84 block 87 | {0x3f, 0x42, 0x54, 0x44, 0x54, 0x42, 0x3f}, //85 cat, fox 88 | {0x02, 0x05, 0x02, 0x38, 0x44, 0x44, 0x28}, //86 celsius 89 | {0x02, 0x05, 0x02, 0x08, 0x7c, 0x48, 0x60}, //87 temperature 90 | {0x02, 0x05, 0x02, 0x7c, 0x10, 0x28, 0x44}, //88 kelvin 91 | {0x14, 0x14, 0x7f, 0x14, 0x7f, 0x14, 0x14}, //89 tag 92 | {0x00, 0x41, 0x63, 0x36, 0x1c, 0x08, 0x00}, //90 chevron right 93 | {0x00, 0x08, 0x1c, 0x36, 0x63, 0x41, 0x00}, //91 chevron left 94 | {0x30, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30}, //92 chevron up 95 | {0x06, 0x0c, 0x18, 0x30, 0x18, 0x0c, 0x06}, //93 chevron down 96 | {0x00, 0x30, 0x48, 0x48, 0x3f, 0x00, 0x00}, //94 note 1 97 | {0x00, 0x30, 0x78, 0x78, 0x3f, 0x00, 0x00}, //95 note 2 98 | {0x00, 0x30, 0x48, 0x48, 0x3f, 0x01, 0x00}, //96 note 3 99 | {0x00, 0x30, 0x78, 0x78, 0x3f, 0x01, 0x00}, //97 note 4 100 | {0x00, 0x30, 0x48, 0x48, 0x3f, 0x05, 0x00}, //98 note 5 101 | {0x00, 0x30, 0x78, 0x78, 0x3f, 0x05, 0x00}, //99 note 6 102 | {0x3f, 0x41, 0x41, 0x41, 0x3f, 0x12, 0x0e}, //100 cup empty 103 | {0x3f, 0x61, 0x61, 0x61, 0x3f, 0x12, 0x0e}, //101 cup 20% 104 | {0x3f, 0x71, 0x71, 0x71, 0x3f, 0x12, 0x0e}, //102 cup 40% 105 | {0x3f, 0x79, 0x79, 0x79, 0x3f, 0x12, 0x0e}, //103 cup 60% 106 | {0x3f, 0x7d, 0x7d, 0x7d, 0x3f, 0x12, 0x0e}, //104 cup 80% 107 | {0x3f, 0x7f, 0x7f, 0x7f, 0x3f, 0x12, 0x0e}, //105 cup 100% 108 | {0x07, 0x09, 0x51, 0x71, 0x51, 0x09, 0x07}, //106 wine class 109 | {0x07, 0x39, 0x41, 0x41, 0x41, 0x39, 0x07}, //107 glass 110 | {0x04, 0x06, 0x7f, 0x7f, 0x7f, 0x02, 0x07}, //108 hammer 111 | {0x7f, 0x41, 0x41, 0x42, 0x42, 0x42, 0x7c}, //109 folder outline 112 | {0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7c}, //110 folder 113 | {0x7f, 0x41, 0x41, 0x52, 0x7a, 0x52, 0x7c}, //111 add folder 114 | {0x0c, 0x18, 0x10, 0x77, 0x10, 0x18, 0x0c}, //112 microphone 115 | {0x70, 0x00, 0x7f, 0x00, 0x7c, 0x00, 0x7e}, //113 equalizer 116 | {0x7f, 0x7f, 0x3e, 0x1c, 0x08, 0x00, 0x7f}, //114 next 117 | {0x7f, 0x00, 0x08, 0x1c, 0x3e, 0x7f, 0x7f}, //115 prev 118 | {0x1f, 0x51, 0x51, 0x71, 0x51, 0x51, 0x1f}, //116 monitor, display 119 | {0x3c, 0x72, 0x71, 0x01, 0x71, 0x72, 0x3c}, //117 headset, earphones 120 | {0x1c, 0x3e, 0x08, 0x08, 0x08, 0x3e, 0x1c}, //118 workout, fitness 121 | {0x7f, 0x0a, 0x05, 0x0a, 0x05, 0x0a, 0x05}, //119 sport flag 122 | {0x08, 0x08, 0x14, 0x63, 0x14, 0x08, 0x08}, //120 location 123 | {0x60, 0x70, 0x78, 0x7c, 0x7e, 0x01, 0x5d}, //121 cellular 1 124 | {0x60, 0x50, 0x48, 0x44, 0x42, 0x01, 0x5d}, //122 cellular 2 125 | {0x60, 0x50, 0x48, 0x44, 0x42, 0x41, 0x7f}, //123 cellular 3 126 | {0x60, 0x70, 0x78, 0x7c, 0x7e, 0x7f, 0x7f}, //124 cellular 4 127 | {0x23, 0x36, 0x3c, 0x38, 0x36, 0x6f, 0x5f}, //125 cellular 5 128 | {0x60, 0x70, 0x78, 0x04, 0x56, 0x27, 0x57}, //126 cellular 6 129 | {0x44, 0x22, 0x22, 0x44, 0x22, 0x22, 0x44}, //127 waves 130 | {0x18, 0x74, 0x52, 0x51, 0x52, 0x74, 0x18}, //128 home 131 | {0x3e, 0x41, 0x55, 0x41, 0x55, 0x41, 0x3e}, //129 dice 1 132 | {0x3e, 0x41, 0x45, 0x41, 0x51, 0x41, 0x3e}, //130 dice 2 133 | {0x1c, 0x27, 0x24, 0x64, 0x24, 0x27, 0x1c}, //131 plug 134 | {0x78, 0x44, 0x42, 0x41, 0x52, 0x44, 0x78}, //132 home 2 135 | {0x70, 0x50, 0x71, 0x52, 0x54, 0x58, 0x70}, //133 radio 136 | {0x14, 0x3e, 0x63, 0x2a, 0x63, 0x3e, 0x14}, //134 memory 137 | {0x49, 0x5d, 0x49, 0x41, 0x51, 0x45, 0x41}, //135 gamepad 138 | {0x78, 0x48, 0x6a, 0x49, 0x6d, 0x49, 0x7a}, //136 router 139 | {0x3e, 0x41, 0x55, 0x61, 0x55, 0x41, 0x3e}, //137 smile 1 140 | {0x3e, 0x41, 0x65, 0x51, 0x65, 0x41, 0x3e}, //138 smile 2 141 | {0x3e, 0x41, 0x55, 0x51, 0x55, 0x41, 0x3e}, //139 smile 3 142 | {0x3e, 0x41, 0x45, 0x51, 0x45, 0x41, 0x3e}, //140 smile 4 143 | {0x3e, 0x41, 0x4d, 0x61, 0x4d, 0x41, 0x3e}, //141 smile 5 144 | {0x01, 0x03, 0x7f, 0x5d, 0x55, 0x55, 0x7f}, //142 sms 145 | {0x1e, 0x3f, 0x3f, 0x3f, 0x33, 0x33, 0x1e}, //143 toggle on 146 | {0x1e, 0x2d, 0x2d, 0x21, 0x21, 0x21, 0x1e}, //144 toggle off 147 | {0x00, 0x00, 0x7f, 0x3e, 0x1c, 0x08, 0x00}, //145 arrow type 1 right 148 | {0x00, 0x08, 0x1c, 0x3e, 0x7f, 0x00, 0x00}, //146 arrow type 1 left 149 | {0x04, 0x0c, 0x1c, 0x3c, 0x1c, 0x0c, 0x04}, //147 arrow type 1 down 150 | {0x10, 0x18, 0x1c, 0x1e, 0x1c, 0x18, 0x10}, //148 arrow type 1 up 151 | {0x08, 0x08, 0x08, 0x7f, 0x3e, 0x1c, 0x08}, //149 arrow type 2 right 152 | {0x08, 0x1c, 0x3e, 0x7f, 0x08, 0x08, 0x08}, //150 arrow type 2 left 153 | {0x08, 0x18, 0x38, 0x7f, 0x38, 0x18, 0x08}, //151 arrow type 2 down 154 | {0x08, 0x0c, 0x0e, 0x7f, 0x0e, 0x0c, 0x08}, //152 arrow type 2 up 155 | {0x02, 0x39, 0x44, 0x54, 0x44, 0x39, 0x02}, //153 alarm clock 156 | {0x1c, 0x22, 0x1c, 0x08, 0x18, 0x08, 0x38}, //154 key 157 | }; 158 | 159 | 160 | int icons_8x8[][] = { 161 | {0xff, 0x85, 0x89, 0x91, 0x91, 0x89, 0x85, 0xff}, //0 email 162 | {0x3c, 0x5e, 0xa3, 0x03, 0x03, 0xe3, 0x7e, 0x3c}, //1 github 163 | {0x80, 0xc0, 0xe6, 0xef, 0xef, 0xe6, 0xc0, 0x80}, //2 user 164 | {0xf0, 0xfe, 0xf1, 0x91, 0x91, 0xf1, 0xfe, 0xf0}, //3 lock, password 165 | {0x18, 0x7e, 0x7e, 0xe7, 0xe7, 0x7e, 0x7e, 0x18}, //4 cog, settings 166 | {0x3c, 0x42, 0x81, 0x9d, 0x91, 0x91, 0x42, 0x3c}, //5 clock 167 | {0x1e, 0x33, 0x21, 0x21, 0x33, 0x7e, 0xe0, 0xc0}, //6 search 168 | {0x7e, 0x3f, 0x15, 0x15, 0x15, 0x1d, 0x1f, 0x0e}, //7 message 169 | {0x00, 0x42, 0x24, 0x18, 0xff, 0x99, 0x66, 0x00}, //8 bluetooth 170 | {0x00, 0x3c, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e},//9 battery 100% 171 | {0x00, 0x3c, 0x7e, 0x42, 0x7e, 0x7e, 0x7e, 0x7e},//10 battery 75% 172 | {0x00, 0x3c, 0x7e, 0x42, 0x42, 0x7e, 0x7e, 0x7e},//11 battery 50% 173 | {0x00, 0x3c, 0x7e, 0x42, 0x42, 0x42, 0x7e, 0x7e},//12 battery 25% 174 | {0x00, 0x3c, 0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e},//13 battery 0% 175 | {0xe7, 0x81, 0x81, 0x00, 0x00, 0x81, 0x81, 0xe7}, //14 full screen 176 | {0x24, 0x24, 0xe7, 0x00, 0x00, 0xe7, 0x24, 0x24}, //15 small screen 177 | {0x02, 0xfa, 0x8b, 0xfb, 0xfb, 0x8b, 0xfa, 0x02}, //16 trash, remove, delete 178 | {0x7c, 0x82, 0x83, 0x82, 0xb2, 0xb3, 0x82, 0x7c}, //17 calendar 179 | {0x7e, 0x81, 0x81, 0x9d, 0x98, 0x94, 0x82, 0x71}, //18 minimize 180 | {0x7e, 0x81, 0x81, 0x91, 0x88, 0x85, 0x83, 0x77}, //19 maximize 181 | {0x7c, 0x44, 0xe7, 0xa5, 0xa5, 0xe7, 0x44, 0x7c}, //20 printer 182 | {0x00, 0x18, 0x18, 0x24, 0x24, 0xc3, 0xc3, 0x00}, //21 share 183 | {0x1c, 0x3e, 0x73, 0xe1, 0xe1, 0x73, 0x3e, 0x1c}, //22 map 184 | {0xd8, 0x88, 0xde, 0xda, 0xda, 0xde, 0x88, 0xd8}, //23 case 185 | {0xe0, 0xfc, 0xfe, 0xa3, 0xfe, 0xfc, 0xe0, 0x00}, //24 warning 186 | {0x3c, 0x7e, 0xe7, 0xe7, 0xe7, 0xe7, 0x7e, 0x3c}, //25 error 187 | {0x3c, 0x42, 0x81, 0x99, 0x99, 0x81, 0x42, 0x3c}, //26 record 188 | {0xff, 0xff, 0xff, 0x7e, 0x7e, 0x3c, 0x3c, 0x18}, //27 play 189 | {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, //28 stop 190 | {0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00}, //29 pause 191 | {0xff, 0x7e, 0x3c, 0x18, 0xff, 0x7e, 0x3c, 0x18}, //30 forward 192 | {0x18, 0x3c, 0x7e, 0xff, 0x18, 0x3c, 0x7e, 0xff}, //31 backward 193 | {0x07, 0x0f, 0x1f, 0xff, 0xff, 0x1f, 0x0f, 0x07}, //32 filter 194 | {0x07, 0x09, 0x11, 0xe1, 0xe1, 0x11, 0x09, 0x07}, //33 filter outline 195 | {0x3c, 0x7e, 0xff, 0x00, 0x18, 0x42, 0x3c, 0x00}, //34 sound 100% 196 | {0x3c, 0x7e, 0xff, 0x00, 0x18, 0x00, 0x00, 0x00}, //35 sound 50% 197 | {0x3c, 0x7e, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00}, //36 sound 0% 198 | {0x01, 0x02, 0x3c, 0x7e, 0xff, 0x20, 0x40, 0x80}, //37 sound off 199 | {0xe0, 0x88, 0x90, 0xbf, 0xbf, 0x90, 0x88, 0xe0}, //38 download 200 | {0xe0, 0x84, 0x82, 0xbf, 0xbf, 0x82, 0x84, 0xe0}, //39 upload 201 | {0x7e, 0x81, 0xa1, 0xa1, 0xaf, 0xa9, 0x8a, 0x7c}, //40 text file 202 | {0xf0, 0x88, 0xa0, 0x92, 0x49, 0x05, 0x11, 0x0f}, //41 link 203 | {0xe0, 0x90, 0x88, 0x44, 0x26, 0x19, 0x0a, 0x04}, //42 pencil 204 | {0xfe, 0x7f, 0x3f, 0x1f, 0x1f, 0x3f, 0x7f, 0xfe}, //43 bookmark 205 | {0x00, 0x98, 0xdc, 0xfe, 0x7f, 0x3b, 0x19, 0x18}, //44 flash, lighting 206 | {0x7e, 0x81, 0x99, 0xa5, 0xa5, 0xa5, 0xa1, 0x9e}, //45 attach 207 | {0x1e, 0x3f, 0x7f, 0xfe, 0xfe, 0x7f, 0x3f, 0x1e}, //46 heart 208 | {0x1e, 0x21, 0x41, 0x82, 0x82, 0x41, 0x21, 0x1e}, //47 heart outline 209 | {0x72, 0x77, 0x77, 0xff, 0xff, 0x77, 0x77, 0x27}, //48 direction 210 | {0x18, 0x24, 0x42, 0x5a, 0x5a, 0x42, 0x24, 0x18}, //49 eye, visible 211 | {0x06, 0x09, 0x11, 0xff, 0xff, 0x11, 0x09, 0x06}, //50 antenna 212 | {0x00, 0xe0, 0x00, 0xf0, 0x00, 0xfc, 0x00, 0xff}, //51 mobile network 100% 213 | {0x00, 0xe0, 0x00, 0xf0, 0x00, 0xfc, 0x00, 0x80}, //52 mobile network 75% 214 | {0x00, 0xe0, 0x00, 0xf0, 0x00, 0x80, 0x00, 0x80}, //53 mobile network 50% 215 | {0x00, 0xe0, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80}, //54 mobile network 25% 216 | {0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80}, //55 mobile network 0% 217 | {0x20, 0x40, 0xff, 0x00, 0x00, 0xff, 0x02, 0x04}, //56 sync 218 | {0x7e, 0x7e, 0x7e, 0x7e, 0x3c, 0x18, 0x3c, 0x7e}, //57 video 219 | {0x02, 0x09, 0x25, 0x95, 0x95, 0x25, 0x09, 0x02}, //58 wifi 220 | {0x70, 0x88, 0x84, 0x84, 0xa4, 0x98, 0x90, 0x60}, //59 cloud 221 | {0x01, 0x0a, 0xf8, 0xfb, 0xf8, 0x0a, 0x01, 0x00}, //60 flashlight on 222 | {0x00, 0x08, 0xf8, 0x88, 0xf8, 0x08, 0x00, 0x00}, //61 flashlight off 223 | {0x70, 0x4e, 0x41, 0xc1, 0xc1, 0x41, 0x4e, 0x70}, //62 bell 224 | {0xf0, 0xfe, 0xf1, 0x91, 0x91, 0xf1, 0xf2, 0xf0}, //63 unlock 225 | {0x3c, 0x00, 0xff, 0x81, 0x81, 0xff, 0x00, 0x3c}, //64 vibrate 226 | {0x7e, 0x81, 0x91, 0xa1, 0x91, 0x89, 0x84, 0x72}, //65 checked 227 | {0x7e, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x7e}, //66 unchecked 228 | {0x54, 0x00, 0xff, 0x81, 0x81, 0xff, 0x00, 0x54}, //67 chip 229 | {0x48, 0x48, 0xfd, 0x82, 0x82, 0xfd, 0x48, 0x48}, //68 bug 230 | {0xff, 0x89, 0xe9, 0xa9, 0xa9, 0xe9, 0x8a, 0xfc}, //69 save 231 | {0xfe, 0xa2, 0x92, 0x8a, 0x8a, 0xcc, 0x28, 0x18}, //70 open 232 | {0xc0, 0xe0, 0x70, 0x3e, 0x19, 0x11, 0x10, 0x0c}, //71 tool 233 | {0xff, 0xdd, 0xeb, 0xb7, 0xbf, 0xbf, 0xbf, 0xff}, //72 console 234 | {0xdb, 0xdb, 0x00, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb}, //73 todo, list 235 | {0xe7, 0xe7, 0xe7, 0x00, 0x00, 0xe2, 0xe7, 0xe2}, //74 apps 236 | {0xf1, 0x8a, 0xa4, 0x84, 0x84, 0xa4, 0x8a, 0xf1}, //75 android 237 | {0x00, 0x0e, 0x71, 0xa1, 0xa1, 0x71, 0x0e, 0x00}, //76 bulb 238 | {0x7e, 0x81, 0x99, 0x99, 0x18, 0x5a, 0x3c, 0x18}, //77 logout 239 | {0x18, 0x18, 0x5a, 0x3c, 0x99, 0x81, 0x81, 0x7e}, //78 login 240 | {0x3e, 0x41, 0x49, 0x5d, 0x49, 0x41, 0xfe, 0xc0}, //79 zoom in 241 | {0x3e, 0x41, 0x49, 0x49, 0x49, 0x41, 0xfe, 0xc0}, //80 zoom out 242 | {0xff, 0xff, 0xff, 0x00, 0xf7, 0xf7, 0xf7, 0xf7}, //81 dashboard 243 | {0xc3, 0x99, 0x3c, 0x7e, 0x7e, 0x3c, 0x99, 0xc3}, //82 all out 244 | {0xc0, 0xe0, 0xf1, 0xff, 0xff, 0xf1, 0xe0, 0xc0}, //83 science 245 | {0x3c, 0x42, 0xa1, 0x91, 0x89, 0x85, 0x42, 0x3c}, //84 block 246 | {0x7f, 0x82, 0xb4, 0x84, 0x84, 0xb4, 0x82, 0x7f}, //85 cat, fox 247 | {0x06, 0x09, 0x09, 0x06, 0x78, 0x84, 0x84, 0x48}, //86 celsius 248 | {0x06, 0x09, 0x09, 0x06, 0x08, 0xfc, 0x88, 0xc0}, //87 temperature 249 | {0x06, 0x09, 0x09, 0x06, 0xf8, 0x20, 0x50, 0x88}, //88 kelvin 250 | {0x24, 0x24, 0xff, 0x24, 0x24, 0xff, 0x24, 0x24}, //89 tag 251 | {0x00, 0x00, 0x81, 0xc3, 0x66, 0x3c, 0x18, 0x00}, //90 chevron right 252 | {0x00, 0x18, 0x3c, 0x66, 0xc3, 0x81, 0x00, 0x00}, //91 chevron left 253 | {0x30, 0x18, 0x0c, 0x06, 0x06, 0x0c, 0x18, 0x30}, //92 chevron up 254 | {0x0c, 0x18, 0x30, 0x60, 0x60, 0x30, 0x18, 0x0c}, //93 chevron down 255 | {0x00, 0x60, 0x90, 0x90, 0x7f, 0x00, 0x00, 0x00}, //94 note 1 256 | {0x00, 0x60, 0xf0, 0xf0, 0x7f, 0x00, 0x00, 0x00}, //95 note 2 257 | {0x00, 0x60, 0x90, 0x90, 0x7f, 0x01, 0x01, 0x00}, //96 note 3 258 | {0x00, 0x60, 0xf0, 0xf0, 0x7f, 0x01, 0x01, 0x00}, //97 note 4 259 | {0x00, 0x60, 0x90, 0x90, 0x7f, 0x05, 0x05, 0x00}, //98 note 5 260 | {0x00, 0x60, 0xf0, 0xf0, 0x7f, 0x05, 0x05, 0x00}, //99 note 6 261 | {0x7f, 0x81, 0x81, 0x81, 0x81, 0x7f, 0x22, 0x1e}, //100 cup empty 262 | {0x7f, 0xe1, 0xe1, 0xe1, 0xe1, 0x7f, 0x22, 0x1e}, //101 cup 20% 263 | {0x7f, 0xf1, 0xf1, 0xf1, 0xf1, 0x7f, 0x22, 0x1e}, //102 cup 40% 264 | {0x7f, 0xf9, 0xf9, 0xf9, 0xf9, 0x7f, 0x22, 0x1e}, //103 cup 60% 265 | {0x7f, 0xfd, 0xfd, 0xfd, 0xfd, 0x7f, 0x22, 0x1e}, //104 cup 80% 266 | {0x7f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x22, 0x1e}, //105 cup 100% 267 | {0x07, 0x09, 0x91, 0xe1, 0xe1, 0x91, 0x09, 0x07}, //106 wineglass 268 | {0x07, 0x19, 0xe1, 0x81, 0x81, 0xe1, 0x19, 0x07}, //107 glass 269 | {0x04, 0x06, 0xff, 0xff, 0xff, 0x06, 0x0f, 0x0f}, //108 hammer 270 | {0xff, 0x81, 0x81, 0x81, 0x82, 0x82, 0x82, 0xfc}, //109 folder outline 271 | {0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfc}, //110 folder 272 | {0xff, 0x81, 0x81, 0x91, 0xba, 0x92, 0x82, 0xfc}, //111 add folder 273 | {0x1c, 0x30, 0x20, 0xef, 0xef, 0x20, 0x30, 0x1c}, //112 microphone 274 | {0xe0, 0xe0, 0x00, 0xff, 0xff, 0x00, 0xfc, 0xfc}, //113 equalizer 275 | {0xff, 0xff, 0xff, 0x7e, 0x3c, 0x18, 0x00, 0xff}, //114 next 276 | {0xff, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0xff}, //115 prev 277 | {0x3f, 0xa1, 0xa1, 0xe1, 0xe1, 0xa1, 0xa1, 0x3f}, //116 monitor, display 278 | {0x7c, 0xe2, 0xe1, 0x01, 0x01, 0xe1, 0xe2, 0x7c}, //117 headset, earphones 279 | {0x18, 0x3c, 0x7e, 0x18, 0x18, 0x7e, 0x3c, 0x18}, //118 workout, fitness 280 | {0xff, 0x0a, 0x15, 0x0a, 0x15, 0x0a, 0x15, 0x0a}, //119 sport flag 281 | {0x18, 0x18, 0x24, 0xc3, 0xc3, 0x24, 0x18, 0x18}, //120 location 282 | {0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0x01, 0xbd}, //121 cellular 1 283 | {0xc0, 0xa0, 0x90, 0x88, 0x84, 0x82, 0x01, 0xbd}, //122 cellular 2 284 | {0xc0, 0xa0, 0x90, 0x88, 0x84, 0x82, 0x81, 0xff}, //123 cellular 3 285 | {0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff, 0xff}, //124 cellular 4 286 | {0x43, 0x66, 0x7c, 0x78, 0x74, 0x6e, 0xdf, 0xbf}, //125 cellular 5 287 | {0xc0, 0xe0, 0xf0, 0xf8, 0x0c, 0xae, 0x4f, 0xaf}, //126 cellular 6 288 | {0x92, 0x49, 0x49, 0x92, 0x92, 0x49, 0x49, 0x92}, //127 waves 289 | {0x18, 0xf4, 0x92, 0x91, 0x91, 0x92, 0xf4, 0x18}, //128 home 290 | {0x7e, 0x81, 0xa5, 0x81, 0x81, 0xa5, 0x81, 0x7e}, //129 dice 1 291 | {0x7e, 0x81, 0x85, 0x81, 0x81, 0xa1, 0x81, 0x7e}, //130 dice 2 292 | {0x3c, 0x44, 0x47, 0xc4, 0xc4, 0x47, 0x44, 0x3c}, //131 plug 293 | {0xf8, 0x84, 0x82, 0x81, 0xb1, 0xb2, 0x84, 0xf8}, //132 home 2 294 | {0xf0, 0x90, 0xf0, 0xf1, 0x92, 0x94, 0x98, 0xf0}, //133 radio 295 | {0x24, 0x7e, 0xc3, 0x5a, 0x5a, 0xc3, 0x7e, 0x24}, //134 memory 296 | {0x44, 0x92, 0xba, 0x92, 0x82, 0xaa, 0x82, 0x44}, //135 gamepad 297 | {0x70, 0x88, 0xa8, 0x8a, 0xa9, 0x8d, 0x89, 0x72}, //136 router 298 | {0x7e, 0x81, 0x95, 0xa1, 0xa1, 0x95, 0x81, 0x7e}, //137 smile 1 299 | {0x7e, 0x81, 0xa5, 0x91, 0x91, 0xa5, 0x81, 0x7e}, //138 smile 2 300 | {0x7e, 0x81, 0xa5, 0xa1, 0xa1, 0xa5, 0x81, 0x7e}, //139 smile 3 301 | {0x7e, 0x81, 0x85, 0xb1, 0xb1, 0x85, 0x81, 0x7e}, //140 smile 4 302 | {0x7e, 0x81, 0x8d, 0xe1, 0xe1, 0x8d, 0x81, 0x7e}, //141 smile 5 303 | {0x01, 0x03, 0xff, 0xfb, 0xbb, 0xab, 0xab, 0xff}, //142 sms 304 | {0x3c, 0x7e, 0x7e, 0x7e, 0x7e, 0x66, 0x66, 0x3c}, //143 toggle on 305 | {0x3c, 0x5a, 0x5a, 0x42, 0x42, 0x42, 0x42, 0x3c}, //144 toggle off 306 | {0x00, 0x00, 0xff, 0x7e, 0x3c, 0x18, 0x00, 0x00}, //145 arrow type 1 right 307 | {0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0x00, 0x00}, //146 arrow type 1 left 308 | {0x04, 0x0c, 0x1c, 0x3c, 0x3c, 0x1c, 0x0c, 0x04}, //147 arrow type 1 down 309 | {0x20, 0x30, 0x38, 0x3c, 0x3c, 0x38, 0x30, 0x20}, //148 arrow type 1 up 310 | {0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18}, //149 arrow type 2 right 311 | {0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18}, //150 arrow type 2 left 312 | {0x10, 0x30, 0x70, 0xff, 0xff, 0x70, 0x30, 0x10}, //151 arrow type 2 down 313 | {0x08, 0x0c, 0x0e, 0xff, 0xff, 0x0e, 0x0c, 0x08}, //152 arrow type 2 up 314 | {0x02, 0x79, 0x85, 0xb4, 0xa4, 0x85, 0x79, 0x02}, //153 alarm clock 315 | {0x3c, 0x42, 0x42, 0x3c, 0x08, 0x18, 0x08, 0x38}, //154 key 316 | }; 317 | 318 | 319 | int size = 8; 320 | 321 | void setup() { 322 | size(810, 700); 323 | background(50); 324 | fill(0xff00ffff); 325 | noStroke(); 326 | rectMode(CENTER); 327 | textAlign(CENTER); 328 | 329 | for (int i = 0; i < 155; i++) { 330 | for (int j = 0; j < size; j++) { 331 | for (int k = 0; k < size; k++) { 332 | if (((icons_8x8[i][j] >> k) & 1) == 1) 333 | rect(10 + (i%16)*50+j*5, 10 + (int(i/16))*70 + k*5, 5, 5); 334 | } 335 | } 336 | textSize(18); 337 | text(i, 25 + (i%16)*50, (i/16)*70 + 65); 338 | } 339 | } 340 | -------------------------------------------------------------------------------- /src/GyverOLED.h: -------------------------------------------------------------------------------- 1 | /* 2 | GyverOLED - лёгкая и быстрая библиотека для OLED дисплея 3 | Документация: 4 | GitHub: https://github.com/GyverLibs/GyverOLED 5 | Возможности: 6 | - Поддержка OLED дисплеев на SSD1306/SSH1106 с разрешением 128х64 и 128х32 с подключением по I2C 7 | - Выбор буфера 8 | - Вообще без буфера (и без особой потери возможностей) 9 | - Буфер на стороне МК (тратит кучу оперативки, но удобнее в работе) 10 | - Обновление буфера в выбранном месте (для быстрой отрисовки) 11 | - Динамический буфер выбранного размера (вся геометрия, текст, байты) 12 | - TODO: Буфер на стороне дисплея (только для SSH1106!!!) 13 | - Вывод текста 14 | - Самый быстрый вывод текста среди OLED библиотек 15 | - Поддержка русского языка и буквы ё (!) 16 | - Более приятный шрифт (по сравнению с beta) 17 | - Координаты вне дисплея для возможности прокрутки 18 | - Вывод текста в любую точку (попиксельная адресация) 19 | - Полноэкранный вывод с удалением лишних пробелов 20 | - 4 размера букв (на базе одного шрифта, экономит кучу памяти!) 21 | - Возможность писать чёрным-по-белому и белым-по-чёрному 22 | - Управление дисплеем 23 | - Установка яркости 24 | - Быстрая инверсия всего дисплея 25 | - Включение/выключение дисплея из скетча 26 | - Изменение ориентации дисплея (зеркально по вертикали и горизонтали) 27 | - Графика (контур, заливка, очистка) 28 | - Точки 29 | - Линии 30 | - Прямоугольники 31 | - Прямоугольники со скруглёнными углами 32 | - Окружности 33 | - Кривые Безье 34 | - Изображения (битмап) 35 | - Вывод битмапа в любую точку дисплея 36 | - Вывод "за дисплей" 37 | - Программа для конвертации изображений есть в библиотеке 38 | - Поддержка библиотеки microWire для ATmega328 (очень лёгкий и быстрый вывод) 39 | 40 | AlexGyver, alex@alexgyver.ru 41 | https://alexgyver.ru/ 42 | MIT License 43 | 44 | Версии (beta) 45 | v0.1 (27.02.2021) - исправил непечатающуюся нижнюю строку 46 | v0.2 (16.03.2021) - исправлены символы [|]~$ 47 | v0.3 (26.03.2021) - добавил кривую Безье 48 | v0.4 (10.04.2021) - совместимость с есп 49 | v0.5 (09.05.2021) - добавлена поддержка SPI и SSH1106 (только буфер)! gnd-vcc-sck-data-rst-dc-cs 50 | 51 | v1.0 - релиз 52 | v1.1 - улучшен перенос строк (не убирает первый символ просто так) 53 | v1.2 - переделан FastIO 54 | v1.3 - прямоугольники можно рисовать из любого угла 55 | v1.3.1 - пофиксил линии (сломались в 1.3.0) 56 | v1.3.2 - убран FastIO 57 | v1.4 - пофикшены SPI дисплеи 58 | v1.5 - пофикшен битый вывод после очистки без указания курсора 59 | v1.6 - добавлен выбор пинов I2C для espX, исправлены мелкие баги, добавлена возможность отключить модуль текста 60 | */ 61 | 62 | #ifndef GyverOLED_h 63 | #define GyverOLED_h 64 | 65 | // ===== константы ===== 66 | #define SSD1306_128x32 0 67 | #define SSD1306_128x64 1 68 | #define SSH1106_128x64 2 69 | 70 | #define OLED_I2C 0 71 | #define OLED_SPI 1 72 | 73 | #define OLED_NO_BUFFER 0 74 | #define OLED_BUFFER 1 75 | 76 | #define OLED_CLEAR 0 77 | #define OLED_FILL 1 78 | #define OLED_STROKE 2 79 | 80 | #define BUF_ADD 0 81 | #define BUF_SUBTRACT 1 82 | #define BUF_REPLACE 2 83 | 84 | #define BITMAP_NORMAL 0 85 | #define BITMAP_INVERT 1 86 | 87 | // =========================================================================== 88 | 89 | #if defined(USE_MICRO_WIRE) 90 | #include // лёгкая библиотека Wire (для atmega328) 91 | #else 92 | #include // обычная Wire 93 | #endif 94 | 95 | #include 96 | #include 97 | 98 | #include "charMap.h" 99 | 100 | #ifndef OLED_NO_PRINT 101 | #include 102 | #endif 103 | 104 | // ============================ БЭКЭНД КОНСТАНТЫ ============================== 105 | // внутренние константы 106 | #define OLED_WIDTH 128 107 | #define OLED_HEIGHT_32 0x02 108 | #define OLED_HEIGHT_64 0x12 109 | #define OLED_64 0x3F 110 | #define OLED_32 0x1F 111 | 112 | #define OLED_DISPLAY_OFF 0xAE 113 | #define OLED_DISPLAY_ON 0xAF 114 | 115 | #define OLED_COMMAND_MODE 0x00 116 | #define OLED_ONE_COMMAND_MODE 0x80 117 | #define OLED_DATA_MODE 0x40 118 | #define OLED_ONE_DATA_MODE 0xC0 119 | 120 | #define OLED_ADDRESSING_MODE 0x20 121 | #define OLED_HORIZONTAL 0x00 122 | #define OLED_VERTICAL 0x01 123 | 124 | #define OLED_NORMAL_V 0xC8 125 | #define OLED_FLIP_V 0xC0 126 | #define OLED_NORMAL_H 0xA1 127 | #define OLED_FLIP_H 0xA0 128 | 129 | #define OLED_CONTRAST 0x81 130 | #define OLED_SETCOMPINS 0xDA 131 | #define OLED_SETVCOMDETECT 0xDB 132 | #define OLED_CLOCKDIV 0xD5 133 | #define OLED_SETMULTIPLEX 0xA8 134 | #define OLED_COLUMNADDR 0x21 135 | #define OLED_PAGEADDR 0x22 136 | #define OLED_CHARGEPUMP 0x8D 137 | 138 | #define OLED_NORMALDISPLAY 0xA6 139 | #define OLED_INVERTDISPLAY 0xA7 140 | 141 | #define BUFSIZE_128x64 (128 * 64 / 8) 142 | #define BUFSIZE_128x32 (128 * 32 / 8) 143 | 144 | #ifndef OLED_SPI_SPEED 145 | #define OLED_SPI_SPEED 1000000ul 146 | #endif 147 | 148 | static SPISettings OLED_SPI_SETT(OLED_SPI_SPEED, MSBFIRST, SPI_MODE0); 149 | 150 | // список инициализации 151 | static const uint8_t _oled_init[] PROGMEM = { 152 | OLED_DISPLAY_OFF, 153 | OLED_CLOCKDIV, 154 | 0x80, // value 155 | OLED_CHARGEPUMP, 156 | 0x14, // value 157 | OLED_ADDRESSING_MODE, 158 | OLED_VERTICAL, 159 | OLED_NORMAL_H, 160 | OLED_NORMAL_V, 161 | OLED_CONTRAST, 162 | 0x7F, // value 163 | OLED_SETVCOMDETECT, 164 | 0x40, // value 165 | OLED_NORMALDISPLAY, 166 | OLED_DISPLAY_ON, 167 | }; 168 | 169 | // ========================== КЛАСС КЛАСС КЛАСС ============================= 170 | template 171 | #ifndef OLED_NO_PRINT 172 | class GyverOLED : public Print { 173 | #else 174 | class GyverOLED { 175 | #endif 176 | public: 177 | // ========================== КОНСТРУКТОР ============================= 178 | GyverOLED(uint8_t address = 0x3C) : _address(address) {} 179 | 180 | // ============================= СЕРВИС =============================== 181 | // инициализация 182 | void init(int __attribute__((unused)) sda = 0, int __attribute__((unused)) scl = 0) { 183 | if (_CONN) { 184 | SPI.begin(); 185 | pinMode(_CS, OUTPUT); 186 | fastWrite(_CS, 1); 187 | pinMode(_DC, OUTPUT); 188 | if (_RST > 0) { 189 | pinMode(_RST, OUTPUT); 190 | fastWrite(_RST, 1); 191 | delay(1); 192 | fastWrite(_RST, 0); 193 | delay(20); 194 | fastWrite(_RST, 1); 195 | } 196 | } else { 197 | #if defined(ESP32) || defined(ESP8266) 198 | if (sda || scl) Wire.begin(sda, scl); 199 | else Wire.begin(); 200 | #else 201 | Wire.begin(); 202 | #endif 203 | } 204 | 205 | beginCommand(); 206 | for (uint8_t i = 0; i < 15; i++) sendByte(pgm_read_byte(&_oled_init[i])); 207 | endTransm(); 208 | beginCommand(); 209 | sendByte(OLED_SETCOMPINS); 210 | sendByte(_TYPE ? OLED_HEIGHT_64 : OLED_HEIGHT_32); 211 | sendByte(OLED_SETMULTIPLEX); 212 | sendByte(_TYPE ? OLED_64 : OLED_32); 213 | endTransm(); 214 | 215 | setCursorXY(0, 0); 216 | if (_BUFF) setWindow(0, 0, _maxX, _maxRow); // для буфера включаем всю область 217 | } 218 | 219 | // очистить дисплей 220 | void clear() { fill(0); } 221 | 222 | // очистить область 223 | void clear(int x0, int y0, int x1, int y1) { 224 | if (_TYPE < 2) { // для SSD1306 225 | if (_BUFF) rect(x0, y0, x1, y1, OLED_CLEAR); 226 | else { 227 | x1++; 228 | y1++; 229 | y0 >>= 3; 230 | y1 = (y1 - 1) >> 3; 231 | y0 = constrain(y0, 0, _maxRow); 232 | y1 = constrain(y1, 0, _maxRow); 233 | x0 = constrain(x0, 0, _maxX); 234 | x1 = constrain(x1, 0, _maxX); 235 | setWindow(x0, y0, x1, y1); 236 | beginData(); 237 | for (int x = x0; x < x1; x++) 238 | for (int y = y0; y < y1 + 1; y++) 239 | writeData(0, y, x, 2); 240 | endTransm(); 241 | } 242 | } else { 243 | // для SSH1108 244 | } 245 | setCursorXY(_x, _y); 246 | } 247 | 248 | // яркость 0-255 249 | void setContrast(uint8_t value) { sendCommand(OLED_CONTRAST, value); } 250 | 251 | // вкл/выкл 252 | void setPower(bool mode) { sendCommand(mode ? OLED_DISPLAY_ON : OLED_DISPLAY_OFF); } 253 | 254 | // отразить по горизонтали 255 | void flipH(bool mode) { sendCommand(mode ? OLED_FLIP_H : OLED_NORMAL_H); } 256 | 257 | // инвертировать дисплей 258 | void invertDisplay(bool mode) { sendCommand(mode ? OLED_INVERTDISPLAY : OLED_NORMALDISPLAY); } 259 | 260 | // отразить по вертикали 261 | void flipV(bool mode) { sendCommand(mode ? OLED_FLIP_V : OLED_NORMAL_V); } 262 | 263 | // ============================= ПЕЧАТЬ ================================== 264 | virtual size_t write(uint8_t data) { 265 | #ifndef OLED_NO_PRINT 266 | // переносы и пределы 267 | bool newPos = false; 268 | if (data == '\r') { 269 | _x = 0; 270 | newPos = true; 271 | data = 0; 272 | } // получен возврат каретки 273 | if (data == '\n') { 274 | _y += _scaleY; 275 | newPos = true; 276 | data = 0; 277 | _getn = 1; 278 | } // получен перевод строки 279 | if (_println && (_x + 6 * _scaleX) >= _maxX) { 280 | _x = 0; 281 | _y += _scaleY; 282 | newPos = true; 283 | } // строка переполненена, перевод и возврат 284 | if (newPos) setCursorXY(_x, _y); // переставляем курсор 285 | if (_y + _scaleY > _maxY + 1) data = 0; // дисплей переполнен 286 | if (_getn && _println && data == ' ' && _x == 0) { 287 | _getn = 0; 288 | data = 0; 289 | } // убираем первый пробел в строке 290 | 291 | // фикс русских букв и некоторых символов 292 | if (data > 127) { 293 | uint8_t thisData = data; 294 | // data = 0 - флаг на пропуск 295 | if (data > 191) data = 0; 296 | else if (_lastChar == 209 && data == 145) data = 192; // ё кастомная 297 | else if (_lastChar == 208 && data == 129) data = 149; // Е вместо Ё 298 | else if (_lastChar == 226 && data == 128) data = 0; // тире вместо длинного тире (начало) 299 | else if (_lastChar == 128 && data == 148) data = 45; // тире вместо длинного тире 300 | _lastChar = thisData; 301 | } 302 | if (data == 0) return 1; 303 | // если тут не вылетели - печатаем символ 304 | 305 | if (_TYPE < 2 || 1) { // для SSD1306 306 | int newX = _x + _scaleX * 6; 307 | if (newX < 0 || _x > _maxX) _x = newX; // пропускаем вывод "за экраном" 308 | else { 309 | if (!_BUFF) beginData(); 310 | for (uint8_t col = 0; col < 6; col++) { // 6 стобиков буквы 311 | uint8_t bits = getFont(data, col); // получаем байт 312 | if (_invState) bits = ~bits; // инверсия 313 | if (_scaleX == 1) { // если масштаб 1 314 | if (_x >= 0 && _x <= _maxX) { // внутри дисплея 315 | if (_shift == 0) { // если вывод без сдвига на строку 316 | writeData(bits, 0, 0, _mode); // выводим 317 | } else { // со сдвигом 318 | writeData(bits << _shift, 0, 0, _mode); // верхняя часть 319 | writeData(bits >> (8 - _shift), 1, 0, _mode); // нижняя часть 320 | } 321 | } 322 | } else { // масштаб 2, 3 или 4 - растягиваем шрифт 323 | uint32_t newData = 0; // буфер 324 | for (uint8_t i = 0, count = 0; i < 8; i++) 325 | for (uint8_t j = 0; j < _scaleX; j++, count++) 326 | bitWrite(newData, count, bitRead(bits, i)); // пакуем растянутый шрифт 327 | 328 | for (uint8_t i = 0; i < _scaleX; i++) { // выводим. По Х 329 | byte prevData = 0; 330 | if (_x + i >= 0 && _x + i <= _maxX) // внутри дисплея 331 | for (uint8_t j = 0; j < _scaleX; j++) { // выводим. По Y 332 | byte data = newData >> (j * 8); // получаем кусок буфера 333 | if (_shift == 0) { // если вывод без сдвига на строку 334 | writeData(data, j, i, _mode); // выводим 335 | } else { // со сдвигом 336 | writeData((prevData >> (8 - _shift)) | (data << _shift), j, i, _mode); // склеиваем и выводим 337 | prevData = data; // запоминаем предыдущий 338 | } 339 | } 340 | if (_shift != 0) writeData(prevData >> (8 - _shift), _scaleX, i, _mode); // выводим нижний кусочек, если со сдвигом 341 | } 342 | } 343 | _x += _scaleX; // двигаемся на ширину пикселя (1-4) 344 | } 345 | if (!_BUFF) endTransm(); 346 | } 347 | } else { 348 | // для SSH1106 349 | } 350 | #endif 351 | return 1; 352 | } 353 | 354 | // автоматически переносить текст 355 | void autoPrintln(bool mode) { _println = mode; } 356 | 357 | // отправить курсор в 0,0 358 | void home() { setCursorXY(0, 0); } 359 | 360 | // поставить курсор для символа 0-127, 0-8(4) 361 | void setCursor(int x, int y) { setCursorXY(x, y << 3); } 362 | 363 | // поставить курсор для символа 0-127, 0-63(31) 364 | void setCursorXY(int x, int y) { 365 | _x = x; 366 | _y = y; 367 | setWindowShift(x, y, _maxX, _scaleY); 368 | } 369 | 370 | // масштаб шрифта (1-4) 371 | void setScale(uint8_t scale) { 372 | scale = constrain(scale, 1, 4); // защита от нечитающих доку 373 | _scaleX = scale; 374 | _scaleY = scale * 8; 375 | setCursorXY(_x, _y); 376 | } 377 | 378 | // инвертировать текст (0-1) 379 | void invertText(bool inv) { _invState = inv; } 380 | 381 | void textMode(byte mode) { _mode = mode; } 382 | 383 | // возвращает true, если дисплей "кончился" - при побуквенном выводе 384 | bool isEnd() { return (_y > _maxRow); } 385 | 386 | // ================================== ГРАФИКА ================================== 387 | // точка (заливка 1/0) 388 | void dot(int x, int y, byte fill = 1) { 389 | if (x < 0 || x > _maxX || y < 0 || y > _maxY) return; 390 | _x = 0; 391 | _y = 0; 392 | if (_BUFF) { 393 | bitWrite(_oled_buffer[_bufIndex(x, y)], y & 0b111, fill); 394 | } else { 395 | if (!_buf_flag) { 396 | setWindow(x, y >> 3, _maxX, _maxRow); 397 | beginData(); 398 | sendByte(!!fill << (y & 0b111)); // задвигаем 1 на высоту y 399 | endTransm(); 400 | } else { 401 | x -= _bufX; 402 | y -= _bufY; 403 | if (x < 0 || x > _bufsizeX || y < 0 || y > (_bufsizeY << 3)) return; 404 | bitWrite(_buf_ptr[(y >> 3) + x * _bufsizeY], y & 0b111, fill); 405 | } 406 | } 407 | } 408 | 409 | // линия 410 | void line(int x0, int y0, int x1, int y1, byte fill = 1) { 411 | _x = 0; 412 | _y = 0; 413 | if (x0 == x1) fastLineV(x0, y0, y1, fill); 414 | else if (y0 == y1) fastLineH(y0, x0, x1, fill); 415 | else { 416 | int sx, sy, e2, err; 417 | int dx = abs(x1 - x0); 418 | int dy = abs(y1 - y0); 419 | sx = (x0 < x1) ? 1 : -1; 420 | sy = (y0 < y1) ? 1 : -1; 421 | err = dx - dy; 422 | for (;;) { 423 | dot(x0, y0, fill); 424 | if (x0 == x1 && y0 == y1) return; 425 | e2 = err << 1; 426 | if (e2 > -dy) { 427 | err -= dy; 428 | x0 += sx; 429 | } 430 | if (e2 < dx) { 431 | err += dx; 432 | y0 += sy; 433 | } 434 | } 435 | } 436 | } 437 | 438 | // горизонтальная линия 439 | void fastLineH(int y, int x0, int x1, byte fill = 1) { 440 | _x = 0; 441 | _y = 0; 442 | if (x0 > x1) _swap(x0, x1); 443 | if (y < 0 || y > _maxY) return; 444 | if (x0 == x1) { 445 | dot(x0, y, fill); 446 | return; 447 | } 448 | x1++; 449 | x0 = constrain(x0, 0, _maxX); 450 | x1 = constrain(x1, 0, _maxX); 451 | if (_BUFF) { 452 | for (int x = x0; x < x1; x++) dot(x, y, fill); 453 | } else { 454 | if (_buf_flag) { 455 | for (int x = x0; x < x1; x++) dot(x, y, fill); 456 | return; 457 | } 458 | byte data = 0b1 << (y & 0b111); 459 | y >>= 3; 460 | setWindow(x0, y, x1, y); 461 | beginData(); 462 | for (int x = x0; x < x1; x++) writeData(data, y, x); 463 | endTransm(); 464 | } 465 | } 466 | 467 | // вертикальная линия 468 | void fastLineV(int x, int y0, int y1, byte fill = 1) { 469 | _x = 0; 470 | _y = 0; 471 | if (y0 > y1) _swap(y0, y1); 472 | if (x < 0 || x > _maxX) return; 473 | if (y0 == y1) { 474 | dot(x, y0, fill); 475 | return; 476 | } 477 | y1++; 478 | if (_BUFF) { 479 | for (int y = y0; y < y1; y++) dot(x, y, fill); 480 | } else { 481 | if (_buf_flag) { 482 | for (int y = y0; y < y1; y++) dot(x, y, fill); 483 | return; 484 | } 485 | if (fill) fill = 255; 486 | byte shift = y0 & 0b111; 487 | byte shift2 = 8 - (y1 & 0b111); 488 | if (shift2 == 8) shift2 = 0; 489 | int height = y1 - y0; 490 | y0 >>= 3; 491 | y1 = (y1 - 1) >> 3; 492 | byte numBytes = y1 - y0; 493 | setWindow(x, y0, x, y1); 494 | 495 | beginData(); 496 | if (numBytes == 0) { 497 | if (_inRange(y0, 0, _maxRow)) writeData((fill >> (8 - height)) << shift, y0, x); 498 | } else { 499 | if (_inRange(y0, 0, _maxRow)) writeData(fill << shift, y0, x); // начальный кусок 500 | y0++; 501 | for (byte i = 0; i < numBytes - 1; i++, y0++) 502 | if (_inRange(y0, 0, _maxRow)) writeData(fill, y0, x); // столбик 503 | if (_inRange(y0, 0, _maxRow)) writeData(fill >> shift2, y0, x); // нижний кусок 504 | } 505 | endTransm(); 506 | } 507 | } 508 | 509 | // прямоугольник (лев. верхн, прав. нижн) 510 | void rect(int x0, int y0, int x1, int y1, byte fill = 1) { 511 | _x = 0; 512 | _y = 0; 513 | if (x0 > x1) _swap(x0, x1); 514 | if (y0 > y1) _swap(y0, y1); 515 | if (fill == OLED_STROKE) { 516 | fastLineH(y0, x0 + 1, x1 - 1); 517 | fastLineH(y1, x0 + 1, x1 - 1); 518 | fastLineV(x0, y0, y1); 519 | fastLineV(x1, y0, y1); 520 | } else { 521 | if (x0 == x1 && y0 == y1) { 522 | dot(x0, y0, fill); 523 | return; 524 | } 525 | if (x0 == x1) { 526 | fastLineV(x0, y0, y1, fill); 527 | return; 528 | } 529 | if (y0 == y1) { 530 | fastLineH(y0, x0, x1, fill); 531 | return; 532 | } 533 | if (!_BUFF && fill == OLED_CLEAR) { 534 | clear(x0, y0, x1, y1); 535 | return; 536 | } 537 | 538 | // если рисуем в мини-буфер 539 | if (_buf_flag) { 540 | x0 = constrain(x0, 0, _maxX); 541 | x1 = constrain(x1, 0, _maxX); 542 | for (byte x = x0; x <= x1; x++) fastLineV(x, y0, y1, fill == OLED_FILL ? 1 : 0); 543 | return; 544 | } 545 | byte thisFill = (fill == OLED_FILL ? 0 : 1); 546 | // рисуем в олед и в большой буфер 547 | y1++; 548 | byte shift = y0 & 0b111; 549 | byte shift2 = 8 - (y1 & 0b111); 550 | if (shift2 == 8) shift2 = 0; 551 | int height = y1 - y0; 552 | y0 >>= 3; 553 | y1 = (y1 - 1) >> 3; 554 | byte numBytes = y1 - y0; 555 | x0 = constrain(x0, 0, _maxX); 556 | x1 = constrain(x1, 0, _maxX); 557 | 558 | if (!_BUFF) setWindow(x0, y0, x1, y1); 559 | if (!_BUFF) beginData(); 560 | for (byte x = x0; x <= x1; x++) { 561 | int y = y0; 562 | if (numBytes == 0) { 563 | if (_inRange(y, 0, _maxRow)) writeData((255 >> (8 - height)) << shift, y, x, thisFill); 564 | } else { 565 | if (_inRange(y, 0, _maxRow)) writeData(255 << shift, y, x, thisFill); // начальный кусок 566 | y++; 567 | for (byte i = 0; i < numBytes - 1; i++, y++) 568 | if (_inRange(y, 0, _maxRow)) writeData(255, y, x, thisFill); // столбик 569 | if (_inRange(y, 0, _maxRow)) writeData(255 >> shift2, y, x, thisFill); // нижний кусок 570 | } 571 | } 572 | if (!_BUFF) endTransm(); 573 | } 574 | } 575 | 576 | // прямоугольник скруглённый (лев. верхн, прав. нижн) 577 | void roundRect(int x0, int y0, int x1, int y1, byte fill = OLED_FILL) { 578 | if (fill == OLED_STROKE) { 579 | fastLineV(x0, y0 + 2, y1 - 2); 580 | fastLineV(x1, y0 + 2, y1 - 2); 581 | fastLineH(y0, x0 + 2, x1 - 2); 582 | fastLineH(y1, x0 + 2, x1 - 2); 583 | dot(x0 + 1, y0 + 1); 584 | dot(x1 - 1, y0 + 1); 585 | dot(x1 - 1, y1 - 1); 586 | dot(x0 + 1, y1 - 1); 587 | } else { 588 | fastLineV(x0, y0 + 2, y1 - 2, fill); 589 | fastLineV(x0 + 1, y0 + 1, y1 - 1, fill); 590 | fastLineV(x1 - 1, y0 + 1, y1 - 1, fill); 591 | fastLineV(x1, y0 + 2, y1 - 2, fill); 592 | rect(x0 + 2, y0, x1 - 2, y1, fill); 593 | } 594 | } 595 | 596 | // окружность (центр х, центр у, радиус, заливка) 597 | void circle(int x, int y, int radius, byte fill = OLED_FILL) { 598 | // if (!_BUFF) createBuffer(x - radius, y - radius, x + radius + 1, y + radius); 599 | int f = 1 - radius; 600 | int ddF_x = 1; 601 | int ddF_y = -2 * radius; 602 | int x1 = 0; 603 | int y1 = radius; 604 | 605 | byte fillLine = (fill == OLED_CLEAR) ? 0 : 1; 606 | dot(x, y + radius, fillLine); 607 | dot(x, y - radius, fillLine); 608 | dot(x + radius, y, fillLine); 609 | dot(x - radius, y, fillLine); 610 | // if (fill != OLED_STROKE) fastLineH(y, x - radius, x + radius-1, fillLine); 611 | if (fill != OLED_STROKE) fastLineV(x, y - radius, y + radius - 1, fillLine); 612 | while (x1 < y1) { 613 | if (f >= 0) { 614 | y1--; 615 | ddF_y += 2; 616 | f += ddF_y; 617 | } 618 | x1++; 619 | ddF_x += 2; 620 | f += ddF_x; 621 | if (fill == OLED_STROKE) { 622 | dot(x + x1, y + y1); 623 | dot(x - x1, y + y1); 624 | dot(x + x1, y - y1); 625 | dot(x - x1, y - y1); 626 | dot(x + y1, y + x1); 627 | dot(x - y1, y + x1); 628 | dot(x + y1, y - x1); 629 | dot(x - y1, y - x1); 630 | } else { // FILL / CLEAR 631 | 632 | fastLineV(x + x1, y - y1, y + y1, fillLine); 633 | fastLineV(x - x1, y - y1, y + y1, fillLine); 634 | fastLineV(x + y1, y - x1, y + x1, fillLine); 635 | fastLineV(x - y1, y - x1, y + x1, fillLine); 636 | /* 637 | fastLineH(y + y1, x - x1, x + x1-1, fillLine); 638 | fastLineH(y - y1, x - x1, x + x1-1, fillLine); 639 | fastLineH(y + x1, x - y1, x + y1-1, fillLine); 640 | fastLineH(y - x1, x - y1, x + y1-1, fillLine); 641 | */ 642 | } 643 | } 644 | // if (!_BUFF) sendBuffer(); 645 | } 646 | void bezier(int* arr, uint8_t size, uint8_t dense, uint8_t fill = 1) { 647 | int a[size * 2]; 648 | for (int i = 0; i < (1 << dense); i++) { 649 | for (int j = 0; j < size * 2; j++) a[j] = arr[j]; 650 | for (int j = (size - 1) * 2 - 1; j > 0; j -= 2) 651 | for (int k = 0; k <= j; k++) 652 | a[k] = a[k] + (((a[k + 2] - a[k]) * i) >> dense); 653 | dot(a[0], a[1], fill); 654 | } 655 | } 656 | 657 | // вывести битмап 658 | void drawBitmap(int x, int y, const uint8_t* frame, int width, int height, uint8_t invert = 0, byte mode = 0) { 659 | _x = 0; 660 | _y = 0; 661 | if (invert) invert = 255; 662 | byte left = height & 0b111; 663 | if (left != 0) height += (8 - left); // округляем до ближайшего кратного степени 2 664 | int shiftY = (y >> 3) + (height >> 3); // строка (row) крайнего байта битмапа 665 | setWindowShift(x, y, width, height); // выделяем окно 666 | bool bottom = (_shift != 0 && shiftY >= 0 && shiftY <= _maxRow); // рисовать ли нижний сдвинутый байт 667 | 668 | if (!_BUFF) beginData(); 669 | for (int X = x, countX = 0; X < x + width; X++, countX++) { // в пикселях 670 | byte prevData = 0; 671 | if (_inRange(X, 0, _maxX)) { // мы внутри дисплея по X 672 | for (int Y = y >> 3, countY = 0; Y < shiftY; Y++, countY++) { // в строках (пикс/8) 673 | byte data = pgm_read_word(&(frame[countY * width + countX])) ^ invert; // достаём байт 674 | if (_shift == 0) { // без сдвига по Y 675 | if (_inRange(Y, 0, _maxRow)) writeData(data, Y, X, mode); // мы внутри дисплея по Y 676 | } else { // со сдвигом по Y 677 | if (_inRange(Y, 0, _maxRow)) writeData((prevData >> (8 - _shift)) | (data << _shift), Y, X, mode); // задвигаем 678 | prevData = data; 679 | } 680 | } 681 | if (bottom) writeData(prevData >> (8 - _shift), shiftY, X, mode); // нижний байт 682 | } 683 | } 684 | if (!_BUFF) endTransm(); 685 | } 686 | 687 | // залить весь дисплей указанным байтом 688 | void fill(uint8_t data) { 689 | if (_BUFF) memset(_oled_buffer, data, _bufSize); 690 | else { 691 | if (_TYPE < 2 || 1) { // для SSD1306 692 | setWindow(0, 0, _maxX, _maxRow); 693 | beginData(); 694 | for (int i = 0; i < (_TYPE ? 1024 : 512); i++) sendByte(data); 695 | endTransm(); 696 | } else { // для SSH1108 697 | } 698 | } 699 | setCursorXY(_x, _y); 700 | } 701 | 702 | // шлёт байт в "столбик" setCursor() и setCursorXY() 703 | void drawByte(uint8_t data) { 704 | if (++_x > _maxX) return; 705 | if (_TYPE < 2 || 1) { // для SSD1306 706 | if (!_BUFF) beginData(); 707 | if (_shift == 0) { // если вывод без сдвига на строку 708 | writeData(data); // выводим 709 | } else { // со сдвигом 710 | writeData(data << _shift); // верхняя часть 711 | writeData(data >> (8 - _shift), 1); // нижняя часть со сдвигом на 1 712 | } 713 | if (!_BUFF) endTransm(); 714 | } else { 715 | // для SSH1106 716 | /* 717 | int h = y & 0x07; 718 | if (_BUFF) { 719 | for (int p = 0; p < 2; p++) { 720 | Wire.beginTransmission(_address); 721 | continueCmd(0xB0 + (y >> 3) + p); // Page 722 | continueCmd(0x00 + ((x + 2) & 0x0F)); // Column low nibble 723 | continueCmd(0x10 + ((x + 2) >> 4)); // Column high nibble 724 | continueCmd(0xE0); // Read modify write 725 | Wire.write(OLED_ONE_DATA_MODE); 726 | Wire.endTransmission(); 727 | Wire.requestFrom((int)_address, 2); 728 | Wire.read(); // Dummy read 729 | int j = Wire.read(); 730 | Wire.beginTransmission(_address); 731 | Wire.write(OLED_ONE_DATA_MODE); 732 | Wire.write((data << h) >> (p << 3) | j); 733 | continueCmd(0xEE); // Cancel read modify write 734 | Wire.endTransmission(); 735 | } 736 | } else { 737 | for (int p = 0; p < 2; p++) { 738 | Wire.beginTransmission(_address); 739 | continueCmd(0xB0 + (y >> 3) + p); // Page 740 | continueCmd(0x00 + ((x + 2) & 0x0F)); // Column low nibble 741 | continueCmd(0x10 + ((x + 2) >> 4)); // Column high nibble 742 | Wire.write(OLED_ONE_DATA_MODE); 743 | Wire.write((data << h) >> (p << 3)); 744 | Wire.endTransmission(); 745 | } 746 | }*/ 747 | } 748 | } 749 | 750 | // вывести одномерный байтовый массив (линейный битмап высотой 8) 751 | void drawBytes(uint8_t* data, byte size) { 752 | if (!_BUFF) beginData(); 753 | for (byte i = 0; i < size; i++) { 754 | if (++_x > _maxX) return; 755 | if (_shift == 0) { // если вывод без сдвига на строку 756 | writeData(data[i]); // выводим 757 | } else { // со сдвигом 758 | writeData(data[i] << _shift); // верхняя часть 759 | writeData(data[i] >> (8 - _shift), 1); // нижняя часть со сдвигом на 1 760 | } 761 | } 762 | if (!_BUFF) endTransm(); 763 | } 764 | 765 | // ================================== СИСТЕМНОЕ =================================== 766 | // полностью обновить дисплей из буфера 767 | void update() { 768 | if (_BUFF) { 769 | if (_TYPE < 2) { // для 1306 770 | setWindow(0, 0, _maxX, _maxRow); 771 | beginData(); 772 | // if (_CONN) SPI.transfer(_oled_buffer, _TYPE ? 1024 : 512); 773 | if (_CONN) 774 | for (int i = 0; i < (_TYPE ? 1024 : 512); i++) SPI.transfer(_oled_buffer[i]); 775 | else 776 | for (int i = 0; i < (_TYPE ? 1024 : 512); i++) sendByte(_oled_buffer[i]); 777 | endTransm(); 778 | } else { // для 1106 779 | sendCommand(0x00); 780 | sendCommand(0x10); 781 | sendCommand(0x40); 782 | uint16_t ptr = 0; 783 | for (uint8_t i = 0; i < (64 >> 3); i++) { 784 | sendCommand(0xB0 + i + 0); // set page address 785 | sendCommand(2 & 0xf); // set lower column address 786 | sendCommand(0x10); // set higher column address 787 | for (uint8_t a = 0; a < 8; a++) { 788 | beginData(); 789 | for (uint8_t b = 0; b < (OLED_WIDTH >> 3); b++) { 790 | sendByteRaw(_oled_buffer[((ptr & 0x7F) << 3) + (ptr >> 7)]); 791 | ptr++; 792 | } 793 | endTransm(); 794 | } 795 | } 796 | } 797 | } 798 | } 799 | 800 | // выборочно обновить дисплей из буфера (x0, y0, x1, y1) 801 | void update(int x0, int y0, int x1, int y1) { 802 | if (_BUFF) { 803 | y0 >>= 3; 804 | y1 >>= 3; 805 | setWindow(x0, y0, x1, y1); 806 | beginData(); 807 | for (int x = x0; x <= x1; x++) 808 | for (int y = y0; y <= y1; y++) 809 | if (x >= 0 && x <= _maxX && y >= 0 && y <= _maxRow) 810 | sendByte(_oled_buffer[y + x * (_TYPE ? 8 : 4)]); 811 | endTransm(); 812 | } 813 | } 814 | 815 | // отправить байт по i2с или в буфер 816 | void writeData(byte data, byte offsetY = 0, byte offsetX = 0, int mode = 0) { 817 | if (_BUFF) { 818 | switch (mode) { 819 | case 0: 820 | _oled_buffer[_bufIndex(_x + offsetX, _y) + offsetY] |= data; // добавить 821 | break; 822 | case 1: 823 | _oled_buffer[_bufIndex(_x + offsetX, _y) + offsetY] &= ~data; // вычесть 824 | break; 825 | case 2: 826 | _oled_buffer[_bufIndex(_x + offsetX, _y) + offsetY] = data; // заменить 827 | break; 828 | } 829 | } else { 830 | if (_buf_flag) { 831 | int x = _x - _bufX; 832 | int y = _y - _bufY; 833 | if (x < 0 || x > _bufsizeX || y < 0 || y > (_bufsizeY << 3)) return; 834 | switch (mode) { 835 | case 0: 836 | _buf_ptr[(y >> 3) + x * _bufsizeY] |= data; // добавить 837 | break; 838 | case 1: 839 | _buf_ptr[(y >> 3) + x * _bufsizeY] &= ~data; // вычесть 840 | break; 841 | case 2: 842 | _buf_ptr[(y >> 3) + x * _bufsizeY] = data; // заменить 843 | break; 844 | } 845 | } else { 846 | sendByte(data); 847 | } 848 | } 849 | } 850 | 851 | // окно со сдвигом. x 0-127, y 0-63 (31), ширина в пикселях, высота в пикселях 852 | void setWindowShift(int x0, int y0, int sizeX, int sizeY) { 853 | _shift = y0 & 0b111; 854 | if (!_BUFF) setWindow(x0, (y0 >> 3), x0 + sizeX, (y0 + sizeY - 1) >> 3); 855 | } 856 | 857 | // ================== ДИНАМИЧЕСКИЙ БУФЕР ================ 858 | // создать 859 | bool createBuffer(int x0, int y0, int x1, int y1, byte fill = 0) { 860 | if (!_BUFF) { 861 | _bufX = x0; 862 | _bufY = y0; 863 | _bufsizeX = x1 - x0 + 1; 864 | _bufsizeY = ((y1 - y0) >> 3) + 1; 865 | 866 | int bufSize = _bufsizeX * _bufsizeY; 867 | _buf_ptr = (byte*)malloc(bufSize); 868 | if (_buf_ptr != NULL) { 869 | _buf_flag = true; 870 | memset(_buf_ptr, fill, bufSize); 871 | return true; 872 | } else { 873 | _buf_flag = false; 874 | return false; 875 | } 876 | } 877 | } 878 | 879 | // отправить 880 | void sendBuffer() { 881 | if (!_BUFF) { 882 | if (_buf_flag) { 883 | setWindow(_bufX, _bufY >> 3, _bufX + _bufsizeX, (_bufY >> 3) + _bufsizeY - 1); 884 | beginData(); 885 | for (int i = 0; i < _bufsizeX * _bufsizeY; i++) { 886 | sendByte(_buf_ptr[i]); 887 | } 888 | endTransm(); 889 | _buf_flag = false; 890 | free(_buf_ptr); 891 | } 892 | } 893 | } 894 | 895 | // ========= ЛОУ-ЛЕВЕЛ ОТПРАВКА ========= 896 | 897 | // супер-костыль для либы Wire. Привет индусам! 898 | void sendByte(uint8_t data) { 899 | sendByteRaw(data); 900 | #if !defined(microWire_h) 901 | if (!_CONN) { 902 | _writes++; 903 | if (_writes >= 16) { 904 | endTransm(); 905 | beginData(); 906 | } 907 | } 908 | #endif 909 | } 910 | void sendByteRaw(uint8_t data) { 911 | if (_CONN) SPI.transfer(data); 912 | else Wire.write(data); 913 | } 914 | 915 | // отправить команду 916 | void sendCommand(uint8_t cmd1) { 917 | beginOneCommand(); 918 | sendByteRaw(cmd1); 919 | endTransm(); 920 | } 921 | 922 | // отправить код команды и команду 923 | void sendCommand(uint8_t cmd1, uint8_t cmd2) { 924 | beginCommand(); 925 | sendByteRaw(cmd1); 926 | sendByteRaw(cmd2); 927 | endTransm(); 928 | } 929 | 930 | // выбрать "окно" дисплея 931 | void setWindow(int x0, int y0, int x1, int y1) { 932 | beginCommand(); 933 | sendByteRaw(OLED_COLUMNADDR); 934 | sendByteRaw(constrain(x0, 0, _maxX)); 935 | sendByteRaw(constrain(x1, 0, _maxX)); 936 | sendByteRaw(OLED_PAGEADDR); 937 | sendByteRaw(constrain(y0, 0, _maxRow)); 938 | sendByteRaw(constrain(y1, 0, _maxRow)); 939 | endTransm(); 940 | } 941 | 942 | void beginData() { 943 | startTransm(); 944 | if (_CONN) fastWrite(_DC, 1); 945 | else sendByteRaw(OLED_DATA_MODE); 946 | } 947 | 948 | void beginCommand() { 949 | startTransm(); 950 | if (_CONN) fastWrite(_DC, 0); 951 | else sendByteRaw(OLED_COMMAND_MODE); 952 | } 953 | 954 | void beginOneCommand() { 955 | startTransm(); 956 | if (_CONN) fastWrite(_DC, 0); 957 | else sendByteRaw(OLED_ONE_COMMAND_MODE); 958 | } 959 | 960 | void endTransm() { 961 | if (_CONN) { 962 | fastWrite(_CS, 1); 963 | SPI.endTransaction(); 964 | } else { 965 | Wire.endTransmission(); 966 | _writes = 0; 967 | delayMicroseconds(2); // https://github.com/GyverLibs/GyverOLED/issues/45 968 | } 969 | } 970 | 971 | void startTransm() { 972 | if (_CONN) { 973 | SPI.beginTransaction(OLED_SPI_SETT); 974 | fastWrite(_CS, 0); 975 | } else Wire.beginTransmission(_address); 976 | } 977 | 978 | // получить "столбик-байт" буквы 979 | uint8_t getFont(uint8_t font, uint8_t row) { 980 | #ifndef OLED_NO_PRINT 981 | if (row > 4) return 0; 982 | font = font - '0' + 16; // перевод код символа из таблицы ASCII 983 | if (font <= 95) { 984 | return pgm_read_byte(&(_charMap[font][row])); // для английских букв и символов 985 | } else if (font >= 96 && font <= 111) { // и пизд*ц для русских 986 | return pgm_read_byte(&(_charMap[font + 47][row])); 987 | } else if (font <= 159) { 988 | return pgm_read_byte(&(_charMap[font - 17][row])); 989 | } else { 990 | return pgm_read_byte(&(_charMap[font - 1][row])); // для кастомных (ё) 991 | } 992 | #endif 993 | } 994 | 995 | // ==================== ПЕРЕМЕННЫЕ И КОНСТАНТЫ ==================== 996 | const uint8_t _address = 0x3C; 997 | const uint8_t _maxRow = (_TYPE ? 8 : 4) - 1; 998 | const uint8_t _maxY = (_TYPE ? 64 : 32) - 1; 999 | const uint8_t _maxX = OLED_WIDTH - 1; // на случай добавления мелких дисплеев 1000 | 1001 | // софт. буфер 1002 | const int _bufSize = ((_BUFF == 1) ? (_TYPE ? BUFSIZE_128x64 : BUFSIZE_128x32) : 0); 1003 | uint8_t _oled_buffer[((_BUFF == 1) ? (_TYPE ? BUFSIZE_128x64 : BUFSIZE_128x32) : 0)]; 1004 | 1005 | private: 1006 | // всякое 1007 | void fastWrite(const uint8_t pin, bool val) { 1008 | #if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__) 1009 | if (pin < 8) bitWrite(PORTD, pin, val); 1010 | else if (pin < 14) bitWrite(PORTB, (pin - 8), val); 1011 | else if (pin < 20) bitWrite(PORTC, (pin - 14), val); 1012 | #elif defined(__AVR_ATtiny85__) || defined(__AVR_ATtiny13__) 1013 | bitWrite(PORTB, pin, val); 1014 | #else 1015 | digitalWrite(pin, val); 1016 | #endif 1017 | } 1018 | // индекс в буфере 1019 | int _bufIndex(int x, int y) { 1020 | return ((y) >> 3) + ((x) << (_TYPE ? 3 : 2)); // _y / 8 + _x * (4 или 8) 1021 | } 1022 | void _swap(int& x, int& y) { 1023 | int z = x; 1024 | x = y; 1025 | y = z; 1026 | } 1027 | bool _inRange(int x, int mi, int ma) { 1028 | return x >= mi && x <= ma; 1029 | } 1030 | 1031 | bool _invState = 0; 1032 | bool _println = false; 1033 | bool _getn = false; 1034 | uint8_t _scaleX = 1, _scaleY = 8; 1035 | int _x = 0, _y = 0; 1036 | uint8_t _shift = 0; 1037 | uint8_t _lastChar; 1038 | uint8_t _writes = 0; 1039 | uint8_t _mode = 2; 1040 | 1041 | // дин. буфер 1042 | int _bufsizeX, _bufsizeY; 1043 | int _bufX, _bufY; 1044 | uint8_t* _buf_ptr; 1045 | bool _buf_flag = false; 1046 | }; 1047 | #endif --------------------------------------------------------------------------------