Arduino oled: Arduino подключение OLED 128×64 / 128×32 I2C » Ардуино Уроки

OLED дисплеи и Arduino ||Arduino-diy.com

В статье рассмотрены монохромные OLED дисплеи с разрешением 128×64 и 128×32 пикселей.

Это небольшие экранчики, их диагональ составляет всего около 1”. Основное их преимущество – удобство чтения благодаря высокой контрастности OLED дисплея. Каждый OLED дисплей изготавливается из отдельных 128×64 или 128×32 белых органических (OLED) светодиодов. Каждый светодиод включается/выключается с помощью чипа управления. Так как дисплей сам является источником света, дополнительная подсветка не требуется. Во-первых, это обеспечивает высокую контрастность дисплея, а во-вторых – значительно снижает энергозатраты, необходимы для его питания.

В качестве драйвера в дисплее используется чип SSD1306, который позволяет передавать данные по протоколам I2C, SPI и 8-битному параллельному протоколу. Как правило, столь широкий выбор интерфейсов предоставляет дисплей с разрешающей способностью 128×64 пикселей. В OLED дисплеях с разрешающей способностью 128×32, доступен только протокол SPI. В статье ниже используется именно SPI для подключения, так как он наиболее универсальный и требует малого количества контактов.

Питание OLED дисплеев

OLED дисплею и драйверу необходимо питание 3.3 В и 3.3 В на питание логики, для передачи данных. Питание дисплеев зависит от того, как именно загружен экран, но в основном он тянет около 20 мА и требует напряжение питания 3.3 В. Встроенный драфвер представляет из себя простой переключатель, который преобразует 3.3 В – 5 В в управляющий сигнал для OLED дисплея. Вы можете запускать дисплей от одного источника питания 3.3 В или использовать 3.3 В для питания чипа и до 4.5 В для самого экрана. Или вы можете подключить 3.3 В к чипу и подать 7-9 В непосредственно на контакт питания OLED дисплея.

OLED 128×64 и 128×32 с готовым выходом 5 В

Все OLED экраны можно использовать с питанием и логикой 3.3 В.

Просто подключите контакт GND к «земле», а контакт Vin к источнику питания в диапазоне 3-5 В. В результате на контакте 3Vo будет 3.3 В.

0.96 128×64 OLED

Более старые версии OLED дисплеев 0.96″ 128×64 использовать сложнее, так как по умолчанию они не совместимы с питанием 5 В. То есть, вам надо обеспечивать для них питание 3.3 В.

• VDD — для питания логики 3.3 В. Значение напряжения должно быть 3 или 3.3 В.
• VBAT – это вход для изменения напряжения в диапазоне от 3.3 до 4.2 В.
• VCC – это контакт значения напряжения high для OLED экрана. Если вы используете встроенный преобразователь напряжения, этот контакт подключать не надо. Если вы не используете внутренний преобразователь, подключите его к источнику питания 7-9 В – постоянный ток.

Рекомендуется соединить контакты VDD и VBAT вместе и подключить к 3.3 В, а контакт VCC оставить неподключенным.

Библиотека Arduino и примеры

Для использования небольших монохромных OLED дисплеев вам надо будет установить библиотеки Arduino. Код из библиотеки, которая приведена ниже поддерживает работу с любыми моделями плат Arduino. Кроме того, его можно легко адаптировать и под другие микроконтроллеры. Для передачи данных используется SPI стандарт передачи данных.

Скачать библиотеку для работы OLED дисплея можно на Github — библиотека Adafruit SSD1306. Кликните кнопку DOWNLOAD в левом верхнем углу, извлеките архив и переименуйте папку в Adafruit_SSD1306. Проверьте, чтобы в папке содержались файлы Adafruit_SSD1306.cpp и Adafruit_SSD1306.h, а также папка examples.

Переместите папку Adafruit_SSD1306 в папку Arduino /libraries. Если папка не существует, вам надо ее создать. В Windows путь будет следующим: (home folder)\My Documents\Arduino\libraries, а для Mac или Linux: (home folder)/Documents/Arduino/libraries. Если у вас возникли трудности с библиотеками, ознакомьтесь с полным гайдом по работе и установке библиотек на нашем сайте Arduino-diy.com.

Аналогичную процедуру вам надо будет провести с Github — библиотека Adafurit_GFX.

После установки библиотек Adafruit_SSD1306 и Adafruit_GFX, перезапустите Arduino IDE. Загрузить пример скетча можно через меню: File→Sketchbook→Libraries→Adafruit_SSD1306→SSD1306…

После того как вы завершили подключение дисплея в соответствии с рекомендациями, которые приведены выше, можете загружать скетч на ваш Arduino.

Библиотека не сможет определить размер экрана на уровне кода. Указать размер надо в header файле. Перейдите в папку с библиотекой и откройте файл Adafruit_SSD1306.h. Сверху в нем есть пояснения по адаптации библиотеки к различным дисплеям.

Создание растровых изображений

Вы можете легко создать растровые изображения для отображения на OLED дисплее с помощью LCD assistant software. Сначала создайте изображение с помощью любого фоторедактора (Photoshop, Paint и т.п.). Сохраните это изображение в формате Monochrome Bitmap (bmp):

Установите следующие параметры:

И импортируйте ваше монохромное растровое изображение. Сохраните его (Save output) в cpp файл:

Код, который приведен в примере можно использовать для обработки полученного рисунка

Подключение OLED дисплея 128×64

Паяем контакты

Перед подключением надо установить и спаять контакты на OLED дисплее. Контакты не будут работать без распайки!

Начните с установки рельсы на 8 контактов на вашу монтажную плату. Рельса устанавливается в макетку своими длинными ногами.

Сверху установите ваш OLED дисплей таким образом, чтобы короткие ноги рельсы попали в отверстия дисплея

Теперь спаяйте 8 контактов с 8-ю отверстиями!

I2C или SPI

Одна из хороших особенностей OLED экранов 128×64 – это то, что они могут использовать I2C или SPI протоколы. SPI отрабатывает быстрее, чем I2C, но для подключения надо больше контактов. Кроме того, наладить SPI на некоторых микроконтроллерах проще, чем I2C.

Подключение OLED по I2C

Экран может подключаться по I2C протоколу к любому микроконтроллеру, который поддерживает этот формат. Так как I2C интерфейс используется только для ‘соединения’ дисплея, у вас останется 512 байт RAM памяти на микроконтроллере. Но передать данные с OLED дисплея не получится.

Для начала вам надо соединить два контакта на задней части платы OLED экрана. Оба контакта должны быть ‘замкнуты’ (с помощью распайки), чтобы I2C начал работать!

После этого подключите контакты к Arduino

• GND идет к GND(земля)
• Vin идет к 5V
• Data к I2C SDA (на Uno — это A4, на Mega — это 20, а на Leonardo — digital 2)
• Clk к I2C SCL (на Uno — это A5, на Mega — это 21, а на Leonardo — digital 3)
• RST к 4 (позже вы можете изменить этот пин в коде программы)

Это подключение совпадает с примером, который есть в библиотеке. После того как предложенный вариант отработает, вы можете попробовать другой контакт для Reset (вы не можете поменять контакты SCA и SCL).

Пример находится в: File→Sketchbook→Libraries→Adafruit_SSD1306→SSD1306_128x64_i2c example

Подключение OLED по SPI

По умолчанию плата предусматривает использование SPI, но если вы до этого использовали I2C, вам надо разомкнуть контакты, которые вы замыкали в предыдущем пункте!

После этого подключите контакты к Arduino

• GND идет к ground (земля)
• Vin идет к 5V
• Data к digital 9
• CLK к digital 10
• D/C к digital 11
• RST к digital 13
• CS к digital 12

Это подключение совпадает с примером скетча, который предложен в библиотеке. После запуска и проверке, можете менять пины и программу.

Пример находится в: File→Sketchbook→Libraries→Adafruit_SSD1306→SSD1306_128x64_spi example

Подключение OLED дисплея 128×32

Подключение OLED экрана 128×32 по SPI

OLED экран 128×32 очень просто подключается по SPI так как в нем есть встроенный модуль согласования уровней. Сначала возьмите рельсу 0.1″ с 8 контактами.

Установите контакты на макетной плате длинной стороной, а сверху OLED экран. После этого припаяйте рельсу к OLED PCB.

После этого подключите Arduino — GND подключается к ground (земля), Vin подключается к 5V, DATA к digital 9, CLK к digital 10, D/C к digital 11, RST к digital 13 и CS к digital 12.

Скетч соответствует тому, как вы подключили экран к Arduino. После проверки работоспособности можете попробовать подключить другие контакты.

Пример находится в: File→Sketchbook→Libraries→Adafruit_SSD1306→SSD1306_128x32_SPI example

Если вы используете OLED экран 128×32, убедитесь, что вы раскомментировали строку «#define SSD1306_128_32» в верхней части скетча Adafruit_SSD1306.h. Раскомментировав эту строку, вы изменяете размер буфера.

Подключение OLED экрана 128×32 по I2C

OLED экран 128×32 можно легко подключить и по I2C. Опять-таки, причина в наличии модуля согласования уровней и регулятора. Сначала возьмите рельсу 0.1″ на 6 контактов.

Установите рельсу длинными контактами на макетной плате

Сверху установите OLED экран

Припаяйте рельсу к OLED PCB

Теперь подключите контакты к Arduino

• GND к GND
• Vin к 5V
• SDA к I2C Data (на Uno — это A4, на Mega — это 20, а на Leonardo — digital 2)
• SCL к I2C Clock(на Uno — A5, на Mega — это 21, а на Leonardo — digital 3)
• RST к 4 (вы можете изменить эти контакты в скетче дальше)

Это подключение соответствует тому, которое требуется для работы скетча примера. После того, как пример отработал, вы можете изменить пин RST. Вы не можете изменить контакты I2C, так как они ‘зафиксированы’ на уровне электросхемы.

Пример находится в: File→Sketchbook→Libraries→Adafruit_SSD1306→SSD1306_128x32_i2c example

Подключение старого 128×64 OLED экрана V 1.0

Эта схема подключения рассчитана на более старые 0.96″ OLED экраны, которые поставляются с модулем согласования уровней. Если у вас V2.0, то используйте другую схему подключения.

Версия V1 128×64 OLED экрана работает от 3.3 В и не имеет встроенного модуля согласования уровней, так что для использования этого экрана с 5 В микроконтроллером, вам понадобится внешний модуль согласования. Если ваш микроконтроллер поддерживает 3.3 В, вы можете пропустить дальнейшие шаги.

Предполагается, что вы будете использовать монтажную плату. Возьмите рельсу 0.1″ с 10 контактами

Установите контакты длинными ногами на макетную млату, а потом сверху – левую рельсу контактов OLED экрана.

Припаяйте контакты

Соедините VDD и VBAT (они подключатся к 3.3 В). GND подключается к GND.

Установите модуль согласования уровней CD4050 таким образом, чтобы пин 1 был сверху

Подключите пин 10 к пину D/C, пин 12 к CLK (SPI время) и пин 15 к DAT (SPI данные).

Подключите пин 2 к RES (сброс) и пин 4 к CS (выбор чипа). Пин 1 идет к 3.3 В, а пин 8 к земле.

Вы можете подключить входы модуля согласования уровней к любым контактам, но в данном случае мы подключили digital 13 к контакту 3 модуля согласования, 12 к пину 5, 11 к пину 9, 10 к пину 11 и 9 к пину 14. Это подключение соответствует скетчу-примеру. После того как, приведенное подключение отработает, можете поэксперементировать с другими контактами/пинами.

Оставляйте Ваши комментарии, вопросы и делитесь личным опытом ниже. В дискуссии часто рождаются новые идеи и проекты!

Урок 5. Вывод информации на OLED дисплей

/*————————————————*/

// подключение библиотек для работы  OLED

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

/*————————————————*/

#define OLED_RESET 7

Adafruit_SSD1306 display(OLED_RESET);

/*————————————————*/

const unsigned char PROGMEM logoBmp[] = {

  0x0, 0x0, 0x0, 0x0, 0x1f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x0, 0x0, 0x0, 0x0, 0x3f, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x0, 0x0, 0x0, 0x0, 0x7f, 0x80, 0x38, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x0, 0x0, 0x0, 0x0, 0x7f, 0x80, 0x38, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x0, 0x7f, 0x80, 0x0, 0x7b, 0x80, 0x38, 0x0, 0x0, 0x7c, 0x3c, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x0, 0x7f, 0x80, 0x0, 0x73, 0x80, 0x38, 0x0, 0x0, 0x7e, 0x7c, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x0, 0x7f, 0x80, 0x0, 0x77, 0x80, 0x38, 0x0, 0x0, 0xfe, 0x7c, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x0, 0x73, 0x80, 0x0, 0x7f, 0x80, 0x38, 0x0, 0x0, 0xfe, 0x7c, 0x0, 0x0, 0x3f, 0xc0, 0x0,

  0x0, 0x73, 0x80, 0x0, 0x7f, 0x80, 0x38, 0x0, 0x0, 0xfe, 0x7c, 0x0, 0x0, 0x3f, 0xc0, 0x0,

  0x0, 0x73, 0x80, 0x0, 0x7f, 0x0, 0x38, 0x0, 0x0, 0xfe, 0x7c, 0x0, 0x0, 0x3f, 0xc0, 0x0,

  0x0, 0x77, 0x8f, 0xfc, 0x7c, 0x0, 0x38, 0x0, 0x0, 0xfe, 0x78, 0x0, 0x0, 0x39, 0xc0, 0x0,

  0x0, 0x7f, 0x8f, 0xfc, 0xfc, 0x0, 0x38, 0x0, 0x0, 0xfe, 0xf8, 0x0, 0x0, 0x39, 0xc0, 0x0,

  0x0, 0x7f, 0x8f, 0xfc, 0xf8, 0x3f, 0xb8, 0x0, 0x0, 0xfc, 0xf0, 0x0, 0x0, 0x3b, 0xc0, 0x0,

  0x0, 0x7f, 0x8f, 0x9c, 0xff, 0xbf, 0xbf, 0xc3, 0xf8, 0xfc, 0xf0, 0x38, 0x0, 0x3f, 0xc0, 0x0,

  0x0, 0x7f, 0xe7, 0x1c, 0xff, 0xbf, 0xbf, 0xe7, 0xfc, 0xf8, 0xff, 0xbf, 0x0, 0x3f, 0xc0, 0x0,

  0x0, 0x7f, 0xf7, 0x1c, 0x7f, 0xbf, 0xbf, 0xff, 0xfc, 0xfe, 0xff, 0xbf, 0x0, 0x3f, 0x80, 0x0,

  0x0, 0x73, 0xf7, 0xfc, 0x7b, 0xbb, 0xb9, 0xff, 0xbc, 0xfe, 0xff, 0xbf, 0x0, 0x7f, 0x38, 0x0,

  0x0, 0x70, 0xf7, 0xfc, 0x7b, 0xbf, 0xb8, 0xff, 0x1c, 0xfe, 0xfb, 0xbf, 0x0, 0x7f, 0x39, 0xc0,

  0x0, 0x0, 0x7, 0xfc, 0x3f, 0xbf, 0xb8, 0xfe, 0x1c, 0xfe, 0xf3, 0xbf, 0x0, 0x7f, 0x39, 0xc0,

  0x0, 0x0, 0x0, 0x0, 0x3f, 0xbf, 0xb8, 0xff, 0xfc, 0xee, 0x73, 0xbf, 0x0, 0x3f, 0x39, 0xc0,

  0x0, 0x0, 0x0, 0x0, 0x3f, 0xbf, 0x38, 0xff, 0xfc, 0xee, 0x7f, 0xbf, 0x8c, 0x3f, 0x39, 0xc0,

  0x0, 0x0, 0x0, 0x0, 0x3f, 0x0, 0x0, 0x1f, 0xfc, 0xfe, 0x7f, 0x9f, 0x8c, 0x3f, 0x3b, 0xc0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfe, 0x7f, 0xbf, 0x80, 0x3f, 0x3f, 0xc0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfe, 0x0, 0x7f, 0x0, 0x3f, 0x3f, 0xc0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0x0, 0x3f, 0x3f, 0xc0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0x0, 0x3f, 0x3, 0xe0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x77, 0x0, 0x0, 0xf, 0xe0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x77, 0x0, 0x0, 0xf, 0xe0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x77, 0x0, 0x0, 0xf, 0xc0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x77, 0x0, 0x0, 0xf, 0xc0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x77, 0x0, 0x0, 0xf, 0xc0,

  0x0, 0x0, 0xf8, 0x3e, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x77, 0x0, 0x0, 0xf, 0xc0,

  0x0, 0x0, 0xf8, 0x3f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x0, 0xf1, 0xfc, 0x3f, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x0, 0xf1, 0xfc, 0x3f, 0x87, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x1, 0xf1, 0xfc, 0x3f, 0x87, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x1, 0xf1, 0xdc, 0x7, 0x87, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x3, 0xe0, 0x1c, 0x3, 0x87, 0x0, 0x7, 0xff, 0xc3, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x7, 0xc0, 0x1e, 0x7, 0x87, 0x0, 0x7, 0xff, 0xc7, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x1f, 0xc0, 0x1e, 0xf, 0x87, 0x3, 0x87, 0xff, 0xc7, 0xff, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0,

  0x1f, 0x80, 0x1e, 0x3f, 0x87, 0x3, 0x87, 0xc0, 0xf, 0x8f, 0xff, 0xf3, 0xf0, 0x1f, 0xf0, 0x0,

  0x1f, 0x80, 0xe, 0x3f, 0xc7, 0x3, 0x87, 0x80, 0xf, 0xf, 0xff, 0xf7, 0xf8, 0x1f, 0xf0, 0x0,

  0x1f, 0x80, 0xe, 0x3f, 0xe7, 0x7, 0x8f, 0x80, 0xf, 0x0, 0x0, 0xf7, 0xfc, 0x3f, 0xf0, 0x0,

  0x7, 0x0, 0xe, 0x3f, 0xe7, 0x7, 0x8f, 0x0, 0x1e, 0x0, 0x1, 0xf7, 0xfc, 0x3d, 0xc0, 0x0,

  0x7, 0x0, 0x7e, 0x1, 0xf7, 0x7, 0x8f, 0x0, 0x1e, 0x0, 0x3, 0xe7, 0x3c, 0x3d, 0xc0, 0x0,

  0x7, 0x3, 0xfe, 0x0, 0xf7, 0xff, 0x8f, 0xf8, 0x3e, 0x0, 0x3, 0xe7, 0x3c, 0x39, 0xc0, 0x0,

  0x7, 0xf, 0xfe, 0x0, 0xf7, 0xff, 0x8f, 0xf8, 0x3f, 0x80, 0x7, 0xc7, 0x7c, 0x3d, 0xc0, 0x0,

  0x7, 0xf, 0xf0, 0x0, 0x77, 0xff, 0xf, 0xf8, 0x7f, 0xc0, 0xf, 0x87, 0xfc, 0x3f, 0xc0, 0x0,

  0x7, 0xf, 0x80, 0x0, 0x70, 0x7, 0x0, 0x38, 0xff, 0xc0, 0xf, 0x87, 0xf8, 0x3f, 0xc0, 0x0,

  0x7, 0xe, 0x0, 0x7, 0xf0, 0x7, 0x0, 0x38, 0xfb, 0xc0, 0xf, 0x7, 0xf0, 0x1f, 0xc0, 0x0,

  0xf, 0xe, 0x0, 0x7, 0xf0, 0x7, 0x0, 0x39, 0xf3, 0xc7, 0xff, 0x8f, 0x80, 0x1, 0xc0, 0x0,

  0xf, 0xe, 0x0, 0x7, 0xf0, 0x7, 0x0, 0x39, 0xe7, 0xc7, 0xff, 0x8f, 0xc0, 0x1, 0xc0, 0x0,

  0xf, 0xe, 0xfc, 0x0, 0x0, 0x7, 0x0, 0x39, 0xff, 0xc7, 0xff, 0x9f, 0xc0, 0x1, 0xc0, 0x0,

  0xe, 0xf, 0xfe, 0x0, 0x0, 0x7, 0x0, 0x79, 0xff, 0x80, 0x7c, 0x1f, 0xc1, 0xc1, 0xc0, 0x0,

  0xe, 0xf, 0xff, 0x0, 0x0, 0x7, 0x1, 0xf9, 0xff, 0x0, 0x7c, 0x1f, 0xe1, 0xe1, 0xc0, 0x0,

  0x0, 0xf, 0xff, 0x0, 0x0, 0x7, 0xf, 0xf9, 0xf0, 0x0, 0xf8, 0x1d, 0xe1, 0xf1, 0xc0, 0x0,

  0x0, 0x0, 0xf, 0x0, 0x0, 0x7, 0xf, 0xf1, 0xc0, 0x0, 0xf0, 0x1d, 0xe1, 0xff, 0xc0, 0x0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x8f, 0xc0, 0x0, 0x0, 0xf0, 0x1d, 0xe0, 0xff, 0xc0, 0x0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x80, 0x0, 0x0, 0x0, 0xe0, 0x1f, 0xe0, 0x7f, 0xc0, 0x0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x80, 0x0, 0x0, 0x0, 0xe0, 0x1f, 0xe0, 0x0, 0x0, 0x0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xc0, 0x0, 0x0, 0x0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,

  0

};

/*————————————————*/

void setup() {

  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // инициализация дисплея по интерфейсу I2C, адрес 0x3C

  display.clearDisplay(); // очистка дисплея

  display.drawBitmap(0, 0, logoBmp, 128, 64, WHITE); // рисуем нашу картинку на экране

  display.display(); // выводим её на OLED

}

/*————————————————*/

void loop() {

}

/*————————————————*/

Подключение OLED I2C дисплея с размером экрана 0,96″ и разрешением 128*64 точек к плате Arduino UNO.

Подключение OLED L2C дисплея

VCC —– +5v  (+5 вольт ,но работает и от 3х вольт — проверено на есп 8266) 
GND —–  GND (земля)
SDA —– pin SDA  (pin A4 для Arduino nano V3)
SCL —–  pin SCL (pin A5 для Arduino nano V3)

Библиотеки для OLED L2C дисплея

Скачаит с гитхаба библиотеку Adafruit_SSD1306

После удачного скачивания и установки библиотек, приступаем к тестовому запуску нашего дисплея

Сегодня мы используем библиотеку от Adafruit, и запустим тестовый скетч

загружаем наш скетч и смотрим есть ли у нас отображение на дисплее информации как на видео

если у нас дисплей никак не отреагировал и ничего не отображает, тогда загружаем скетч MultiSpeedI2CScanner

После загрузки скетча открываем монитор порта, устанавливаем скорость 115200 бод

Меню L2C сканера

после чего, в SerialPort отправляем S , для полного сканирования и ищем наше устройство.

Результат полного сканирования

для отображения только подключенных устройств, сначала отправляем P, а потом S

результат сканирования подключенных устройств

Теперь запоминаем или копируем адрес нашего OLED l2C дисплея и в тестовом скетче ищем строку с записью адреса нашего дисплея

прописываем свой адрес и снова загружаем скетч в Arduino UNO. Тестовый скетч должен отображаться на дисплее

Так же не забываем о экономии при покупке товаров на Алиєкспресс с помощью кэшбэка 

Для веб администраторов и владельцев пабликов  главная страница ePN

Для пользователей покупающих на Алиэкспресс с быстрым выводом % главная страница ePN Cashback

Удобный плагин кэшбеэка браузерный плагин ePN Cashback

Подключение OLED l2C дисплея к Arduino UNO

#include <Wire.h>

#include <Arduino.h>

long speed[] = {

  50, 100, 200, 250, 400, 500, 800 };

const int speeds = sizeof(speed)/sizeof(speed[0]);

#define RESTORE_LATENCY  5    

bool delayFlag = false;

bool printAll = true;

bool header = true;

enum states {

  STOP, ONCE, CONT, HELP };

states state = STOP;

uint32_t startScan;

uint32_t stopScan;

void setup()

{

  Serial.begin(115200);

  Wire.begin();

  displayHelp();

}

void loop()

{

  switch (getCommand())

  {

  case ‘s’:

    state = ONCE;

    break;

  case ‘c’:

    state = CONT;

    break;

  case ‘d’:

    delayFlag = !delayFlag;

    Serial.print(F(«<delay=»));

    Serial.println(delayFlag?F(«5>»):F(«0>»));

    break;

  case ‘e’:

    break;

  case ‘h’:

    header = !header;

    Serial.print(F(«<header=»));

    Serial.println(header?F(«yes>»):F(«no>»));

    break;

  case ‘?’:

    state = HELP;

    break;

  case ‘p’:

    printAll = !printAll;

    Serial.print(F(«<print=»));

    Serial.println(printAll?F(«all>»):F(«found>»));

    break;

  case ‘q’:

    state = HELP;

    break;

  default:

    break;

  }

  switch(state)

  {

  case ONCE:

    I2Cscan();

    state = HELP;

    break;

  case CONT:

    I2Cscan();

    delay(1000);

    break;    

  case HELP:

    displayHelp();

    state = STOP;

    break;

  case STOP:

    break;

  default:

    break;

  }

}

char getCommand()

{

  char c = ‘\0’;

  if (Serial.available())

  {

    c = Serial.read();

  }

  return c;

}

void displayHelp()

{

  Serial.println(F(«\nArduino I2C Scanner — 0.1.03\n»));

  Serial.println(F(«\ts = single scan»));

  Serial.println(F(«\tc = continuous scan — 1 second delay»));

  Serial.println(F(«\tq = quit continuous scan»));

  Serial.println(F(«\td = toggle latency delay between successful tests.»));

  Serial.println(F(«\tp = toggle printAll — printFound.»));

  Serial.println(F(«\th = toggle header — noHeader.»));

  Serial.println(F(«\t? = help — this page»));

  Serial.println();

}

void I2Cscan()

{

  startScan = millis();

  uint8_t count = 0;

  if (header)

  {

    Serial.print(F(«TIME\tDEC\tHEX\t»));

    for (uint8_t s = 0; s < speeds; s++)

    {

      Serial.print(F(«\t»));

      Serial.print(speed[s]);

    }

    Serial.println(F(«\t[KHz]»));

    for (uint8_t s = 0; s < speeds + 5; s++)

    {

      Serial.print(F(«———«));

    }

    Serial.println();

  }

  for (uint8_t address = 8; address < 120; address++)

  {

    bool printLine = printAll;

    bool found[speeds];

    bool fnd = false;

    for (uint8_t s = 0; s < speeds ; s++)

    {

      TWBR = (F_CPU/(speed[s]*1000) — 16)/2;

      Wire.beginTransmission (address);

      found[s] = (Wire.endTransmission () == 0);

      fnd |= found[s];

      // give device 5 millis

      if (fnd && delayFlag) delay(RESTORE_LATENCY);

    }

    if (fnd) count++;

    printLine |= fnd;

    if (printLine)

    {

      Serial.print(millis());

      Serial.print(F(«\t»));

      Serial.print(address, DEC);

      Serial.print(F(«\t0x»));

      Serial.print(address, HEX);

      Serial.print(F(«\t»));

      for (uint8_t s = 0; s < speeds ; s++)

      {

        Serial.print(F(«\t»));

        Serial.print(found[s]? F(«V»):F(«.»));

      }

      Serial.println();

    }

  }

  stopScan = millis();

  if (header)

  {

    Serial.println();

    Serial.print(count);

    Serial.print(F(» devices found in «));

    Serial.print(stopScan — startScan);

    Serial.println(F(» milliseconds.»));

  }

}

Программируем OLED экраны SSD1306 и SSD1331 на Arduino.

Всем добрый день! В этом видео мы запрограммируем на вывод текста и графической информации два типа OLED дисплеев, присоединив их к плате Arduino Nano. Один из них — это миниатюрный монохромный OLED-модуль, с разрешением 128/32 пикселей и интерфейсом I2C.
Второй — цветной, с интерфейсом SPI, разрешением 96/64.

OLED дисплеи отличаются от LCD тем, что в них отсутствует дополнительный слой подсветки всей поверхности экрана. Каждый пиксел, формирующий изображение, испускает самостоятельное свечение. При этом картинка получается яркой и контрастной, а энергии потребляется меньше, так что питания от Arduino вполне достаточно.
Сначала подключим монохромный OLED.

Его характеристики такие:
драйвер IC: SSD1306,
интерфейс: I2C,
размер экрана: 0,91 дюйм,
разрешение 128*32,
напряжение поддержки 3,3 В/5 В.
У него 4 контакта: питание, земля и два пина, обеспечивающих связь через I2C интерфейс.

Описание интерфейса I2C.

Контакт VCC лучше подключать к пину Arduino 3.3V.
GND, соответственно, к GND Arduino.
У разных версий Arduino линии данных расположены на разных пинах. В случае Arduino UNO и NANO SDA подключается к пину A4, а SCL к А5. У Arduino Mega SDA к 20, SCL к 21.

Схема подключения приводится ниже:

Теперь подключим цветной OLED экран.

Вот его характеристики:
драйвер: SSD1331,
интерфейс: SPI,
размер экрана: 0,95 дюйм,
разрешение 96*64,
напряжение поддержки 3,3 В/5 В.
У него 8 контактов, вот их описание:

Схема подключения к Arduino NANO следующая.

Вот как мы подключили модули к Arduino с помощью макетной платы.

Устанавливаем библитотеки

Программы для наших экранов пишутся в Arduino IDE (среде разработки под ардуино).

Прежде, нужно установить специальные библиотеки.
Первая библиотека — это Adafruit_GFX. Она содержит графические функции и синтаксис для дисплеев LCD и OLED, адаптируя их под скрипты Arduino.
К этой библиотеке нужна еще специальная библиотека под конкретный дисплей.
Например, под выбранный нами дисплей 128/32 с чипом SSD1306 нужна библиотека Adafruit_SSD1306.
Под дисплей 96/64 с чипом SSD1331 нужна библиотека Adafruit_SSD1331.
Как они установливаются…
Запускаем среду разработки Arduino IDE.
Выбираем на верхней панели Скетч → Подключить библиотеку → Управлять библиотеками.

Откроется менеджер библиотек. В поле поиска набираем название нужной библиотеки. Она отобразится в списке. Щелкаем по ней и нажимаем кнопку (которая появится) «установить». Начинается непродолжительный процесс установки.

Русификация выводимого текста.

Программирование под каждый вид дисплеев имеет свои особенности. Поэтому я приведу текст программы под каждый из наших дисплеев отдельно. Но прежде чем показать все возможности библиотек, нужно поговорить о том, как русифицировать выводимую строку.
Приведу пример программы для нашего монохромного дисплея SSD1306.

/**************************************************************************
 Это пример программы для монохромного OLED экрана основанного на драйвере SSD1306 
**************************************************************************/

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4 // Пин сброса 

/* Создаем объект дисплея SSD1306, подключенного к I2C (выводы SDA, SCL)*/
Adafruit_SSD1306 display(OLED_RESET);

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

  // SSD1306_SWITCHCAPVCC = генерировать внутреннее напряжение на дисплее от 3,3 В
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Инициализирует дисплей. Адрес 0x3C для 128x32
    Serial.println(F("SSD1306 ошибка инициализации"));
    for(;;); // вечный цикл — дальше ничего не делать
  }

 example_draw_text();    //выводим текст
}

void loop() {
}

void example_draw_text(void) {

     display.clearDisplay(); //очищаем дисплей

     display.setTextSize(1); //размер букв        
     display.setTextColor(WHITE); //цвет букв
     display.setCursor(0,0); //координаты текста          
     display.println("Privet"); //текст
     display.display(); //выводим на дисплей все, что было задано
}

И пример такой же программы для цветного дисплея SSD1331.

/***************************************************
Это пример программы для цветного OLED экрана основанного на драйвере SSD1331 
 ****************************************************/

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1331.h>

// Номера подключенных пинов
#define sclk 13
#define mosi 11
#define cs   10
#define rst  9
#define dc   8

//Определяем Цвета
#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF

//  Создаем объект дисплея SSD1331
Adafruit_SSD1331 display = Adafruit_SSD1331(cs, dc, rst);

void setup(void) {

     Serial.begin(9600);

     display.begin(); // Инициализирует дисплей
  
     Serial.println("init");

     example_draw_text();    //выводим текст 
}

void loop() {
}

void example_draw_text(void) {
  
     display.fillScreen(BLACK); //заливаем экран черным цветом
  
     display.setTextSize(1); //размер букв  
     display.setTextColor(RED); //цвет букв
     display.setCursor(0, 0); //координаты текста     
     display.println("Privet"); //выводим текст 
}

Для того, чтобы фразу «Privet» можно было вывести русскими буквами нужно найти папку с библиотекой Adafruit_GFX, которая появилась при установке программы. В этой папке лежит файл «glcdfont.с» со шрифтами. Этот файл нужно заменить на другой, в котором содержатся русские буквы. Его можно скачать по ссылке «Adafruit_GFX_Rusification_file_glcdfont.с.zip» в приложении к этой статье.
Но этого мало, еще нужна перекодировка символов из UTF-8 в русскую кодировку Windows-1251.
Для этого мы в программу добавляем функцию-перекодировщик utf8rus().

String utf8rus(String source)
{
   int i,k;
   String target;
   unsigned char n;
   char m[2] = { '0', '\0' };

   k = source.length(); i = 0;
   while (i < k) 
   {
      n = source[i]; i++;
      if (n >= 0xC0) 
      {
         switch (n) 
         {
            case 0xD0: 
            {
               n = source[i]; i++;
               if (n == 0x81) { n = 0xA8; break; }
               if (n >= 0x90 && n <= 0xBF) n = n + 0x2F;
               break;
            }
           case 0xD1: 
            {
                n = source[i]; i++;
                if (n == 0x91) { n = 0xB8; break; }
                if (n >= 0x80 && n <= 0x8F) n = n + 0x6F;
                break;
            }
         }
      }
      m[0] = n; target = target + String(m);
   }
   return target;
}

Далее, там, где требуется вывод текстовой строки, мы сначала передаем ее этой функции.

  display.println(utf8rus("Привет"));

Программируем OLED дисплеи.

Давайте теперь дополним тексты программ, добавив к ним функции, демонстрирующие все возможности вывода текста и графики на OLED дисплеи.

/**************************************************************************
 Это пример программы для монохромного OLED экрана основанного на драйвере SSD1306 
**************************************************************************/

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4 // Пин сброса 

/* Создаем объект дисплея SSD1306, подключенного к I2C (выводы SDA, SCL)*/
Adafruit_SSD1306 display(OLED_RESET);

int example_delay = 2000; //задержка в миллисекундах между примерами
int step_delay = 1; //задержка в миллисекундах между шагами одного примера

#define LOGONUM     10 // Количество картинок в анимации

#define LOGO_HEIGHT   20
#define LOGO_WIDTH    20
static const unsigned char PROGMEM logo_bmp[] =
{ 
  0x00,0x00,0x0F, // ....................####
  0x00,0x00,0x0F, // ....................####
  0x3E,0x08,0x0F, // ..#####.....#.......####
  0x41,0x90,0x0F, // .#.....##..#........####
  0x60,0x5E,0x0F, // .##......#.####.....####
  0x18,0x71,0x0F, // ...##....###...#....####
  0x0F,0x80,0x8F, // ....#####.......#...####
  0x08,0x00,0x4F, // ....#............#..####
  0x10,0x00,0x4F, // ...#.............#..####
  0x10,0x00,0x4F, // ...#.............#..####
  0x10,0x00,0x4F, // ...#.............#..####
  0x10,0x00,0x4F, // ...#.............#..####
  0x10,0x00,0x4F, // ...#.............#..####
  0x08,0x00,0x4F, // ....#............#..####
  0x08,0x00,0x8F, // ....#...........#...####
  0x04,0x01,0x0F, // .....#.........#....####
  0x02,0x02,0x0F, // ......#.......#.....####
  0x01,0xFC,0x0F, // .......#######......####
  0x00,0x00,0x0F, // ....................####
  0x00,0x00,0x0F  // ....................####
};

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

  // SSD1306_SWITCHCAPVCC = генерировать внутреннее напряжение на дисплее от 3,3 В
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Инициализирует дисплей. Адрес 0x3C для 128x32
    Serial.println(F("SSD1306 ошибка инициализации"));
    for(;;); // вечный цикл — дальше ничего не делать
  }

 //Очищаем буфер
  display.clearDisplay();

  example_fill_screen(); //пример заполнения экрана цветом

  example_scroll_text();    //выводим движущийся текст

  example_draw_pixel(); //пример рисования точек

  example_draw_line();  //пример рисования линий

  example_draw_rect();  //пример рисования прямоугольников

  example_draw_circle();    // пример рисования кругов

  example_draw_triangle();  // пример рисования треугольников

  example_draw_bitmap();    // выводим картинку

  example_animate_bitmap(logo_bmp, LOGO_WIDTH, LOGO_HEIGHT); //анимируем картинку

void loop() {
}

String utf8rus(String source)
{
   int i,k;
   String target;
   unsigned char n;
   char m[2] = { '0', '\0' };

   k = source.length(); i = 0;
   while (i < k) 
   {
      n = source[i]; i++;
      if (n >= 0xC0) 
      {
         switch (n) 
         {
            case 0xD0: 
            {
               n = source[i]; i++;
               if (n == 0x81) { n = 0xA8; break; }
               if (n >= 0x90 && n <= 0xBF) n = n + 0x2F;
               break;
            }
           case 0xD1: 
            {
                n = source[i]; i++;
                if (n == 0x91) { n = 0xB8; break; }
                if (n >= 0x80 && n <= 0x8F) n = n + 0x6F;
                break;
            }
         }
      }
      m[0] = n; target = target + String(m);
   }
   return target;
}

/***************************************************
Это пример программы для цветного OLED экрана основанного на драйвере SSD1331 
 ****************************************************/

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1331.h>

// Номера подключенных пинов
#define sclk 13
#define mosi 11
#define cs   10
#define rst  9
#define dc   8

//Определяем Цвета
#define	BLACK           0x0000
#define	BLUE            0x001F
#define	RED             0xF800
#define	GREEN           0x07E0
#define CYAN            0x07FF
#define MAGENTA         0xF81F
#define YELLOW          0xFFE0
#define WHITE           0xFFFF

//  Создаем объект дисплея SSD1331
Adafruit_SSD1331 display = Adafruit_SSD1331(cs, dc, rst);

int example_delay = 2000; //задержка в миллисекундах между примерами
int step_delay = 100; //задержка в миллисекундах между шагами одного примера

#define LOGONUM     10 // Количество картинок в анимации

#define LOGO_HEIGHT   20
#define LOGO_WIDTH    20
static const unsigned char PROGMEM logo_bmp[] =
{ 
  0x00,0x00,0x0F, // ....................####
  0x00,0x00,0x0F, // ....................####
  0x3E,0x08,0x0F, // ..#####.....#.......####
  0x41,0x90,0x0F, // .#.....##..#........####
  0x60,0x5E,0x0F, // .##......#.####.....####
  0x18,0x71,0x0F, // ...##....###...#....####
  0x0F,0x80,0x8F, // ....#####.......#...####
  0x08,0x00,0x4F, // ....#............#..####
  0x10,0x00,0x4F, // ...#.............#..####
  0x10,0x00,0x4F, // ...#.............#..####
  0x10,0x00,0x4F, // ...#.............#..####
  0x10,0x00,0x4F, // ...#.............#..####
  0x10,0x00,0x4F, // ...#.............#..####
  0x08,0x00,0x4F, // ....#............#..####
  0x08,0x00,0x8F, // ....#...........#...####
  0x04,0x01,0x0F, // .....#.........#....####
  0x02,0x02,0x0F, // ......#.......#.....####
  0x01,0xFC,0x0F, // .......#######......####
  0x00,0x00,0x0F, // ....................####
  0x00,0x00,0x0F  // ....................####
};

void setup(void) {
  Serial.begin(9600);
  display.begin(); // Инициализирует дисплей
  Serial.println("init");
  
  example_fill_screen(); //пример заполнения экрана цветом

  example_show_text(); //пример вывода текста на экран
  
  example_draw_pixel(); //пример рисования точек

  example_draw_line(); //пример рисования линий

  example_draw_rect(); //пример рисования прямоугольников

  example_draw_circle(); // пример рисования кругов

  example_draw_triangle(); // пример рисования треугольников
  
  example_draw_bitmap();    // выводим картинку

  example_animate_bitmap(logo_bmp, LOGO_WIDTH, LOGO_HEIGHT); //анимируем картинку
  
 
void loop() {
}

String utf8rus(String source)
{
   int i,k;
   String target;
   unsigned char n;
   char m[2] = { '0', '\0' };

   k = source.length(); i = 0;
   while (i < k) 
   {
      n = source[i]; i++;
      if (n >= 0xC0) 
      {
         switch (n) 
         {
            case 0xD0: 
            {
               n = source[i]; i++;
               if (n == 0x81) { n = 0xA8; break; }
               if (n >= 0x90 && n <= 0xBF) n = n + 0x2F;
               break;
            }
           case 0xD1: 
            {
                n = source[i]; i++;
                if (n == 0x91) { n = 0xB8; break; }
                if (n >= 0x80 && n <= 0x8F) n = n + 0x6F;
                break;
            }
         }
      }
      m[0] = n; target = target + String(m);
   }
   return target;
}

А теперь приведем реализацию каждой функции, вызванной в setup(), а именно:

  example_fill_screen(); //пример заполнения экрана цветом
  example_scroll_text();    //выводим движущийся текст
  example_draw_pixel(); //пример рисования точек
  example_draw_line();  //пример рисования линий
  example_draw_rect();  //пример рисования прямоугольников
  example_draw_circle();    // пример рисования кругов
  example_draw_triangle();  // пример рисования треугольников
  example_draw_bitmap();    // выводим картинку
  example_animate_bitmap(logo_bmp, LOGO_WIDTH, LOGO_HEIGHT); //анимируем картинку

Пример заполнения экрана цветом.

void example_fill_screen(void) {

  display.clearDisplay();
  
  display.fillScreen(BLACK);
  /*выводим пояснительный текст*/  
  display.setTextSize(1);            
  display.setTextColor(WHITE);      
  display.setCursor(0,0);          
  display.println(utf8rus("Заливка экрана"));
  display.display();     
  delay(example_delay/2);

  display.clearDisplay();
   
  display.fillScreen(WHITE);
  /*выводим пояснительный текст*/  
  display.setTextColor(BLACK);
  display.setCursor(0,0);      
  display.println(utf8rus("Заливка экрана"));
  display.display();     
  delay(example_delay/2);
}

void example_fill_screen(void) {
  
  display.fillScreen(RED);
  /*выводим пояснительный текст*/  
  display.setTextColor(GREEN);
  display.setCursor(0,0);      
  display.println(utf8rus("Заливка экрана"));
  delay(example_delay/2);

  display.fillScreen(GREEN);
  /*выводим пояснительный текст*/  
  display.setTextColor(CYAN);  
  display.setCursor(0,0);    
  display.println(utf8rus("Заливка экрана"));
  delay(example_delay/2);

  display.fillScreen(CYAN);
  /*выводим пояснительный текст*/  
  display.setTextColor(MAGENTA);  
  display.setCursor(0,0);    
  display.println(utf8rus("Заливка экрана"));
  delay(example_delay/2);

  display.fillScreen(MAGENTA);
  /*выводим пояснительный текст*/  
  display.setTextColor(YELLOW); 
  display.setCursor(0,0);     
  display.println(utf8rus("Заливка экрана"));
  delay(example_delay/2);

  display.fillScreen(YELLOW);
  /*выводим пояснительный текст*/  
  display.setTextColor(WHITE);  
  display.setCursor(0,0);    
  display.println(utf8rus("Заливка экрана"));
  delay(example_delay/2);
  
  display.fillScreen(WHITE);
  /*выводим пояснительный текст*/  
  display.setTextColor(BLUE); 
  display.setCursor(0,0);     
  display.println(utf8rus("Заливка экрана"));
  delay(example_delay/2);

  display.fillScreen(BLUE);
  /*выводим пояснительный текст*/  
  display.setTextColor(BLACK); 
  display.setCursor(0,0);     
  display.println(utf8rus("Заливка экрана"));
  delay(example_delay);
}

Пример вывода и анимации строки

void example_scroll_text(void) {

  /*выводим пояснительный текст*/
  display.clearDisplay();

  display.setTextSize(1);            
  display.setTextColor(WHITE);      
  display.setCursor(0,0);          
  display.println(utf8rus("Движущийся текст"));
  display.display();
  delay(example_delay/2);

  display.clearDisplay();

  display.setTextSize(2); 
  display.setTextColor(WHITE);
  display.setCursor(10, 0);
  display.println(utf8rus("Текст"));
  display.display();     
 delay(example_delay/2);

  // Скроллинг текста в разных направлениях
  display.startscrollright(0x00, 0x0F);
 delay(example_delay/2);
  display.stopscroll();
 delay(example_delay/2);
  display.startscrollleft(0x00, 0x0F);
 delay(example_delay/2);
  display.stopscroll();
  delay(example_delay/2);
  display.startscrolldiagright(0x00, 0x07);
 delay(example_delay/2);
  display.startscrolldiagleft(0x00, 0x07);
 delay(example_delay/2);
  display.stopscroll();
  delay(example_delay/2);
}

void example_show_text(void) {
  display.fillScreen(BLACK);
  display.setCursor(0, 0);
  display.setTextColor(RED);
  display.setTextSize(1);
  display.println(utf8rus("Мы напишем"));
  delay(step_delay);
  display.setCursor(0, 15);
  display.setTextColor(YELLOW, GREEN);
  display.setTextSize(2);
  display.print(utf8rus("Классный текст"));
  delay(step_delay);
  display.setCursor(0, 50);
  display.setTextColor(BLUE,WHITE);
  display.setTextSize(1);
  display.print(utf8rus("Для примера"));
  delay(example_delay);  
}

Пример вывода точек

void example_draw_pixel(void) {
  /*выводим пояснительный текст*/
  display.clearDisplay();

  display.setTextSize(1);             
  display.setTextColor(WHITE);        
  display.setCursor(0,0);            
  display.println(utf8rus("Рисуем точки"));
  display.display();
  delay(example_delay/2);

   /*выводим точки*/
  display.clearDisplay();

  int16_t i, j = display.height()/2; 

  for(i=0; i<display.width(); i+=10) {
    display.drawPixel(i, j, WHITE);
    display.display(); 
    delay(step_delay);
  }

  delay(example_delay);
}

 void example_draw_pixel(void) {
 
  /*выводим пояснительный текст*/  
  display.fillScreen(BLACK);
  display.setTextSize(1);            
  display.setTextColor(RED);      
  display.setCursor(0,0);          
  display.println(utf8rus("Рисуем точки"));
  delay(example_delay/2);

  /*выводим точки*/
  display.fillScreen(BLACK); 
  int16_t i, j = display.height()/2; 

  for(i=0; i<display.width(); i+=10) {
    if(i<display.width()/3)
       display.drawPixel(i, j, RED);
    else if( (i>=display.width()/3)&&(i<display.width()/3*2) )
       display.drawPixel(i, j, GREEN);
    else if(i>=display.width()/3*2)
       display.drawPixel(i, j, BLUE);
   
    delay(step_delay);
  }

  delay(example_delay);
}

Пример вывода линий

void example_draw_line(void) {

  /*выводим пояснительный текст*/
  display.clearDisplay();

  display.setTextSize(1);            
  display.setTextColor(WHITE);      
  display.setCursor(0,0);          
  display.println(utf8rus("Рисуем линии"));
  display.display();
  delay(example_delay/2);

  int16_t i;

/*выводим вертикальные линии*/

  display.clearDisplay(); 

  for(i=0; i<display.width(); i+=8) {
    display.drawLine(i, 0, i, 
    display.height()-1, WHITE);
    display.display(); 
    delay(step_delay);
  }

  delay(example_delay/2);

  /*выводим горизонтальные линии*/

  display.clearDisplay();
   
  for(i=0; i<display.height(); i+=4) {
    display.drawLine(0, i, 
    display.width()-1, i, WHITE);
    display.display();
    delay(step_delay);
  }
  
  delay(example_delay/2);

  /*выводим диагональные линии*/

  display.clearDisplay();
 
  for(i=0; i<display.height(); i+=4) {
    display.drawLine(display.width()-1, 0, 0, i, WHITE);
    display.display();
    delay(step_delay);
  }
   for(i=8; i<display.width(); i+=8) {
    display.drawLine(display.width()-1, 0, i, 
    display.height()-1, WHITE);
    display.display();
    delay(step_delay);
  }
 
  delay(example_delay/2);

  display.clearDisplay();

   for(i=0; i<display.width()-1; i+=8) {
    display.drawLine(i, 0, display.width()-1-i, 
    display.height()-1, WHITE);
    display.display();
    delay(step_delay);
  }
   for(i=4; i<display.height()-1; i+=4) {
    display.drawLine(display.width()-1, i, 0, 
    display.height()-1-i, WHITE);
    display.display();
    delay(step_delay);
  }
  
  delay(example_delay); 
}

void example_draw_line(void) {

  /*выводим пояснительный текст*/
  display.fillScreen(BLACK);
  display.setTextSize(1);            
  display.setTextColor(GREEN);      
  display.setCursor(0,0);          
  display.println(utf8rus("Рисуем линии"));
  delay(example_delay/2);

  int16_t i;

  /*выводим вертикальные линии*/

  display.fillScreen(BLACK);

   for (int16_t y=0; y < display.height()-1; y+=4) {
     display.drawFastHLine(0, y, display.width()-1, CYAN);
     delay(step_delay);
   }
   for (int16_t x=0; x < display.width()-1; x+=8) {
     display.drawFastVLine(x, 0, display.height()-1, YELLOW);
     delay(step_delay);
   }

  delay(example_delay/2);

  /*выводим диагональные линии*/

  display.fillScreen(BLACK);
 
  for(i=0; i<display.height(); i+=4) {
    display.drawLine(display.width()-1, 0, 0, i, MAGENTA);
    delay(step_delay);
  }
   for(i=8; i<display.width(); i+=8) {
    display.drawLine(display.width()-1, 0, i, 
    display.height()-1, RED);
    delay(step_delay);
  }
 
  delay(example_delay/2);

  display.fillScreen(BLACK);

   for(i=0; i<display.width()-1; i+=8) {
    display.drawLine(i, 0, display.width()-1-i, 
    display.height()-1, BLUE);
    delay(step_delay);
  }
   for(i=4; i<display.height()-1; i+=4) {
    display.drawLine(display.width()-1, i, 0, 
    display.height()-1-i, CYAN);
    delay(step_delay);
  } 
  
  delay(example_delay); 
}

Пример вывода прямоугольников

void example_draw_rect(void) {

   /*выводим пояснительный текст*/
  display.clearDisplay();

  display.setTextSize(1);            
  display.setTextColor(WHITE);      
  display.setCursor(0,0);          
  display.println(utf8rus("Рисуем прямоугольники"));
  display.display();
  delay(example_delay/2);

  /*выводим прямогугольники вложенные друг в друга*/
  
 display.clearDisplay();

 for(int16_t i=0; i<display.height()/2; i+=2) {
    display.drawRect(i, i, display.width()-2*i, 
    display.height()-2*i, WHITE);
    display.display(); 
    delay(step_delay);
  }

  delay(example_delay/2);

  /*выводим заполненные цветом прямоугольники*/  
   display.clearDisplay();

  for(int16_t i=0; i<display.width()-1; i+=16) {
    display.fillRect(i, 0, 15, display.height()-1, WHITE);
    display.display(); 
    delay(step_delay);
  }

  delay(example_delay/2);

   /*выводим скругленные прямоугольники*/
   display.clearDisplay();

   for(int16_t i=0; i<display.height()/2-2; i+=2) {
    display.drawRoundRect(i, i, display.width()-2*i, 
    display.height()-2*i,
    display.height()/4, WHITE);
    display.display();
    delay(step_delay);
  }

  delay(example_delay/2);

   /*выводим заполненные цветом прямоугольники*/  
   display.clearDisplay();

  for(int16_t i=0; i<display.width()-1; i+=16) {
    display.fillRoundRect(i, 0, 15, display.height()-1, 
    display.height()/4, WHITE);
    display.display(); 
    delay(step_delay);
  }

  delay(example_delay);
}

void example_draw_rect(void) {
  
  /*выводим пояснительный текст*/
  display.fillScreen(BLACK);
  display.setTextSize(1);            
  display.setTextColor(BLUE);      
  display.setCursor(0,0);          
  display.println(utf8rus("Рисуем прямоугольники"));
  delay(example_delay/2);

  /*выводим прямогугольники вложенные друг в друга*/
  
 display.fillScreen(BLACK);

 for(int16_t i=0; i<display.height()/2; i+=2) {
    display.drawRect(i, i, display.width()-2*i, 
    display.height()-2*i, BLUE);
    delay(step_delay);
  }

  /*выводим заполненные цветом прямоугольники*/  
  display.fillScreen(BLACK);
  for(int16_t i=0; i<display.width()-1; i+=16) {
    display.fillRect(i, 0, 15, display.height()-1, MAGENTA);
    display.drawRect(i, 0, 15, display.height()-1, BLUE);
    delay(step_delay);
  }

  delay(example_delay/2);

   /*выводим скругленные прямоугольники*/
   display.fillScreen(BLACK);
 
   for(int16_t i=0; i<display.height()/2-2; i+=2) {
    display.drawRoundRect(i, i, display.width()-2*i, 
    display.height()-2*i,
    display.height()/4, RED);
    delay(step_delay);
  }

  delay(example_delay/2);

  /*выводим заполненные цветом прямоугольники*/  
   display.fillScreen(BLACK);
   
  for(int16_t i=0; i<display.width()-1; i+=16) {
    display.fillRoundRect(i, 0, 15, display.height()-1, 
    display.height()/4, GREEN);
    display.drawRoundRect(i, 0, 15, display.height()-1, 
    display.height()/4, RED);
    delay(step_delay);
  }

  delay(example_delay);
}

Пример вывода кругов

void example_draw_circle(void) {

  /*выводим пояснительный текст*/
  display.clearDisplay();

  display.setTextSize(1);            
  display.setTextColor(WHITE);      
  display.setCursor(0,0);          
  display.println(utf8rus("Рисуем круги"));
  display.display();
  delay(example_delay/2);

  /*выводим круги*/
  display.clearDisplay();

  for(int16_t i=0; i<display.width()-1; 
  i+=display.height()-1) {
    display.drawCircle(i, display.height()/2, 
    display.height()/2-1, WHITE);
    display.display();
    delay(step_delay);
  }

  delay(example_delay/2);

  /*выводим заполненные круги*/
  display.clearDisplay();

  for(int16_t i=0; i<display.width()-1; 
  i+=display.height()-1) {
    display.fillCircle(i, display.height()/2, 
    display.height()/2-1, WHITE);
    display.display();
    delay(step_delay);
  }

  delay(example_delay);
}

void example_draw_circle(void) {

  /*выводим пояснительный текст*/
  display.fillScreen(BLACK);
  display.setTextSize(1);            
  display.setTextColor(CYAN);      
  display.setCursor(0,0);          
  display.println(utf8rus("Рисуем круги"));
  delay(example_delay/2);

  /*выводим круги*/
  display.fillScreen(BLACK);

  int16_t d = display.height()/2-1;
  
   for(int16_t i=d/2; i<=display.width()-d/5; i+=d) {
    display.drawCircle(i, d/2, d/2, MAGENTA);
    delay(step_delay);
  }
  
  for(int16_t i=d; i<=display.width()-d; i+=d) {
    display.drawCircle(i, d+d/2, d/2, MAGENTA);
    delay(step_delay);
  }

  delay(example_delay/2);

  /*выводим заполненные круги*/
  display.fillScreen(BLACK);

  for(int16_t i=d/2; i<=display.width()-d/2; i+=d) {
    display.fillCircle(i, d/2, d/2, CYAN);
    display.drawCircle(i, d/2, d/2, MAGENTA);
    delay(step_delay);
  }
  
  for(int16_t i=d; i<=display.width()-d; i+=d) {
    display.fillCircle(i, d+d/2, d/2, CYAN);
    display.drawCircle(i, d+d/2, d/2, MAGENTA);
    delay(step_delay);
  }
  
  delay(example_delay);
}

Пример вывода треугольников

void example_draw_triangle(void) {

  /*выводим пояснительный текст*/
  display.clearDisplay();

  display.setTextSize(1);            
  display.setTextColor(WHITE);      
  display.setCursor(0,0);          
  display.println(utf8rus("Рисуем треугольники"));
  display.display();
  delay(example_delay/2);

  /*выводим треугольники*/
  display.clearDisplay();

  for(int16_t i=0; i<display.width()-1; 
  i+=display.height()-1) {
    display.drawTriangle(
    i, 0,
    i - (display.height()/2), display.height()-1,
    i + (display.height()/2), display.height()-1, WHITE);
    display.display();
    delay(step_delay);
  }

  delay(example_delay/2);

   /*выводим треугольники заполненные цветом*/

   display.clearDisplay();

   for(int16_t i=0; i<display.width()-1; 
   i+=display.height()-1) {
    display.fillTriangle(
    i, 0,
    i - (display.height()/2), display.height()-1,
    i + (display.height()/2), display.height()-1, WHITE);
    display.display();
    delay(step_delay);
  }

  delay(example_delay);
}

void example_draw_triangle(void) {

  /*выводим пояснительный текст*/
  display.fillScreen(BLACK);
     
  display.setTextSize(1);            
  display.setTextColor(YELLOW);      
  display.setCursor(0,0);          
  display.println(utf8rus("Рисуем треугольники"));
  delay(example_delay/2);

  /*выводим треугольники*/
   display.fillScreen(BLACK);

  int16_t d = display.height()/2-1;
  
  for(int16_t i=0; i<display.width()-d/2; i+=d) {
    display.drawTriangle(
    i, 0,
    i+d/2,d,
    i+d, 0, GREEN);
    delay(step_delay);
  }

  for(int16_t i=d/2; i<display.width()-d; i+=d) {
    display.drawTriangle(
    i, display.height()-1,
    i+d/2,d,
    i+d, display.height()-1, GREEN);
    delay(step_delay);
  }

  delay(example_delay/2);

  /*выводим треугольники заполненные цветом*/
   display.fillScreen(BLACK);

 for(int16_t i=0; i<display.width()-d/2; i+=d) {
    display.fillTriangle(
    i, 0,
    i+d/2,d,
    i+d, 0, YELLOW);
    delay(step_delay);
  }

  for(int16_t i=d/2; i<display.width()-d; i+=d) {
    display.fillTriangle(
    i, display.height()-1,
    i+d/2,d,
    i+d, display.height()-1, YELLOW);
    delay(step_delay);
  }  

  delay(example_delay);
}

Пример вывода картинки

void example_draw_bitmap(void) {
  /*выводим пояснительный текст*/
  display.clearDisplay();

  display.setTextSize(1);            
  display.setTextColor(WHITE);      
  display.setCursor(0,0);          
  display.println(utf8rus("Рисуем картинку"));
  display.display();
  delay(example_delay/2);

  /*выводим картинку*/
  
  display.clearDisplay();
  display.drawBitmap(
    (display.width()  - LOGO_WIDTH ) / 2,
    (display.height() - LOGO_HEIGHT) / 2,
    logo_bmp, LOGO_WIDTH, LOGO_HEIGHT, 1);
  display.display();
  delay(example_delay*2);
}

void example_draw_bitmap(void) {
  /*выводим пояснительный текст*/
  display.fillScreen(BLACK);
  display.setTextSize(1);            
  display.setTextColor(MAGENTA);      
  display.setCursor(0,0);          
  display.println(utf8rus("Рисуем картинку"));
  delay(example_delay/2);

  /*выводим картинку*/
  
  display.fillScreen(BLACK);
  display.drawBitmap(
    (display.width()  - LOGO_WIDTH ) / 2,
    (display.height() - LOGO_HEIGHT) / 2,
    logo_bmp, LOGO_WIDTH, LOGO_HEIGHT, RED);
  delay(example_delay*2);
}

Пример анимации картинки

#define XPOS   0 /* Индексирует в массив 'icons' 
в функции ниже*/
#define YPOS   1
#define DELTAY 2

void example_animate_bitmap(const uint8_t *bitmap, uint8_t w, 
uint8_t h) {

   /*выводим пояснительный текст*/
  display.clearDisplay();

  display.setTextSize(1);            
  display.setTextColor(WHITE);      
  display.setCursor(0,0);          
  display.println(utf8rus("Анимация картинки"));
  display.display();
  delay(example_delay/2);

  /*выводим анимацию*/
  
  int8_t i, f, icons[LOGONUM][3];

  // Инициируем позиции картинок
  for(f=0; f< LOGONUM; f++) {
    icons[f][XPOS]   = random(1 - LOGO_WIDTH, 
    display.width());
    icons[f][YPOS]   = -LOGO_HEIGHT;
    icons[f][DELTAY] = random(1, 6);
    Serial.print(F("x: "));
    Serial.print(icons[f][XPOS], DEC);
    Serial.print(F(" y: "));
    Serial.print(icons[f][YPOS], DEC);
    Serial.print(F(" dy: "));
    Serial.println(icons[f][DELTAY], DEC);
  }

  for(i=0;i<50;i++) { //цикл анимации 50 итераций
    display.clearDisplay(); // Clear the display buffer

    // Рисуем каждую картинку:
    for(f=0; f< LOGONUM; f++) {
      display.drawBitmap(icons[f][XPOS], icons[f][YPOS], 
      bitmap, w, h, WHITE);
    }

    display.display(); // Вывести буфер на экран
    delay(200);        // пауза

    // обновляем координаты каждой картинки...
    for(f=0; f< LOGONUM; f++) {
      icons[f][YPOS] += icons[f][DELTAY];
      // если картинка находится внизу экрана...
      if (icons[f][YPOS] >= display.height()) {
        // Снова инициализируем в случайную позицию
        icons[f][XPOS]   = random(1 - LOGO_WIDTH, 
        display.width());
        icons[f][YPOS]   = -LOGO_HEIGHT;
        icons[f][DELTAY] = random(1, 6);
      }
    }
  }
}

#define XPOS   0 /* Индексирует в массив
'icons' в функции ниже*/
#define YPOS   1
#define DELTAY 2

void example_animate_bitmap(const uint8_t *bitmap, 
uint8_t w, uint8_t h) {

  /*выводим пояснительный текст*/
  display.fillScreen(BLACK);
 
  display.setTextSize(1);            
  display.setTextColor(WHITE);      
  display.setCursor(0,0);          
  display.println(utf8rus("Анимация картинки"));
  delay(example_delay/2);

  /*выводим анимацию*/
  display.fillScreen(BLACK);
  
  int8_t i, f, icons[LOGONUM][3];

  // Инициируем позиции картинок
  for(f=0; f< LOGONUM; f++) {
    icons[f][XPOS]   = random(1 - LOGO_WIDTH, 
    display.width());
    icons[f][YPOS]   = -LOGO_HEIGHT;
    icons[f][DELTAY] = random(1, 6);
  }

  for(i=0;i<50;i++) { //цикл анимации 50 итераций
     display.fillScreen(BLACK);

    // Рисуем каждую картинку:
    for(f=0; f< LOGONUM; f++) {
      display.drawBitmap(icons[f][XPOS], icons[f][YPOS], 
      bitmap, w, h, RED);
    }

    delay(step_delay);        // пауза

    // обновляем координаты каждой картинки...
    for(f=0; f< LOGONUM; f++) {
      icons[f][YPOS] += icons[f][DELTAY];
      // если картинка находится внизу экрана...
      if (icons[f][YPOS] >= display.height()) {
        // Снова инициализируем в случайную позицию
        icons[f][XPOS]   = random(1 - LOGO_WIDTH, 
        display.width());
        icons[f][YPOS]   = -LOGO_HEIGHT;
        icons[f][DELTAY] = random(1, 6);
      }
    }
  }
}

Весь приведенный код можно скачать целиком по ссылкам ниже.
Всем до новых встреч!

UOLED-128G2-AR, 1.5″ OLED Pack for Arduino w/Adaptor Shield + Cable, 4D SYSTEMS

OLED дисплей 0.91″ 128×32, I2C, SSD1306 синий

Подключение OLED дисплея к ARDUINO UNO R3 и вывод Русского шрифта:

А теперь более подробно, что мы делали.

Мы использовали:

1. Arduino UNO R3

2. OLED display 0.96″ I2C (IIC)

4. Библиотека с поддержкой русского и украинского языка OLED I2C

Дисплей подключаем к ARDUINO UNO по следующей схеме:

Вход питания дисплея VDD можно было бы подключить к 3,3V или 5V ARDUINO, но у нас задача обойтись без проводов. Поэтому мы установим цифровому порту ARDUINO 13 значение HIGHT, это значит, что на pin 13 ARDUINO подаст 5 вольт. Подключаем дисплей напрямую в UNO:

Наш Скетч:

Устанавливаем библиотеку OLED_I2C (если не была установлена) и компилируем. Каждая строка в скетче подробно описана:

Таблица соответствия символов:

Для простоты написания, переключаемся на английскую раскладку и набираем текст Русскими буквами!

OLED SSD1306 Дисплей I2C (128×32), интерфейс с Arduino …

OLED или органический светоизлучающий диод — это светоизлучающий диод (LED), в котором излучающий электролюминесцентный слой представляет собой пленку из органического соединения (миллионы маленьких светодиодных лампочек), которая излучает свет в ответ на электрический ток.

OLED-устройство 128 × 32 можно рассматривать как матрицу из 4096 отдельных пикселей, каждый из которых может индивидуально включаться — они светятся — или выключаться — только фон.Поскольку фон чернильно-черный, включенные пиксели довольно хорошо выделяются, а читаемость идеальна. Благодаря такой конфигурации пикселей можно создавать и отображать графические растровые изображения: логотипы, аватары, спрайты.

Дисплей использует микросхему SSD1306 и может взаимодействовать с любым микроконтроллером по протоколу связи I2C / SPI.

• Интерфейс: I2C
• Разрешение: 128 x 32
• Размер экрана по диагонали 0.91 «
• Область отображения: 7 мм x 25 мм / Размер платы 12,0 мм x 39 мм
• Толщина: 4 мм
• Размер пикселя (мм) 0,159 × 0,159
• Технология: OLED Blue
Микросхема графического драйвера
• — SSD1306
• Широкое входное напряжение: 2,5-5,5 В

Этот OLED-дисплей работает по протоколу i2c, поэтому у него всего четыре контакта.

• SDA (последовательные данные) переносит данные.
• Линия тактового сигнала SCL (Serial Clock). Он используется для синхронизации всех передач данных по шине I2C.
• GND идет на заземляющий контакт
• VCC переходит на 5 В

• SDA (Serial Data) — A4 платы Uno (на Mega это 20)
• SCL (Serial Clock) — A5 платы Uno (на Mega это 21)
• VCC — 5 В Uno
• GND- Земля Uno

Для управления OLED-дисплеем вам понадобится Adafruit_GFX.h «и библиотеку» Adafruit_SSD1306.h «. Есть два способа загрузить и установить библиотеку в вашу IDE Arduino. Библиотека Wire.h позволяет взаимодействовать с устройствами I2C / TWI. По умолчанию эта библиотека включена в Arduino IDE.

Метод 1

1. Перейдите в меню «Эскиз».
2. Выберите «Включить библиотеки».
3. Перейти к управлению библиотеками.
4. Найдите ADAFRUIT GFX и УСТАНОВИТЕ его.
5. Найдите ADAFRUIT SSD1306 и УСТАНОВИТЕ его.

Метод 2

Вы можете установить его извне, используя следующую ссылку.
Библиотека дисплея: https://github.com/adafruit/Adafruit_SSD1306
Библиотека GFX: https://github.com/adafruit/Adafruit-GFX-Library

После загрузки zip-файлов,
Перейдите в Sketch → Include Library → Add .ZIP library
Затем добавьте загруженные zip-файлы.
Теперь библиотеки включены в вашу Arduino IDE.

Adafruit содержит действительно хорошие примеры для дисплеев 128×32 и 128×64.

Примеры oled-дисплея можно найти в разделе «Файл»> «Примеры»> «Adafruit SSD1306»>, а затем выбрать тип дисплея в среде Arduino IDE.

Здесь мы отобразили наш логотип и простой растровый рисунок.

https://github.com/elementzonline/Arduino-Sample-Codes/blob/master/OLED_I2C_Sample/OLED_I2C_Sample.ino

image2cpp — это простой инструмент для преобразования изображений в байтовые массивы (или ваш массив обратно в изображение) для использования с Arduino и (монохромными) дисплеями, такими как OLED.Первоначально он был разработан для работы с библиотекой Adafruit OLED.

Инструмент доступен по этой ссылке: https://javl.github.io/image2cpp/

Вы можете легко преобразовать любое изображение в растровый узор и указать этот массив байтов в своем примере кода. Таким образом, мы получим на дисплее нужный узор.

ШАГ 1:

Подключите кабель A к B к USB-порту компьютера и убедитесь, что порт был обнаружен, отметив опцию «Диспетчер устройств».

ШАГ 2:

Откройте два окна IDE Arduino, выберите Arduino UNO в качестве платы и выберите соответствующий COM-порт.

Плата: Инструменты> Плата> Arduino / Geniuno UNO.

ШАГ 3:

Порт: Инструменты> Порт в Arduino.

ШАГ 4:

• Скомпилируйте и загрузите эту программу на свою плату Arduino Uno через Arduino IDE
• После завершения загрузки вы увидите сгенерированные растровые изображения на OLED-дисплее.

Arduino Oled i2c Display 128×64 с примерами, проблемы с библиотеками решены

#include

#include

#include

#include

#define SCREEN_WIDTH 128 // Ширина OLED-дисплея в пикселях

#define SCREEN_HEIGHT 64 // Высота OLED-дисплея в пикселях

// Объявление для дисплея SSD1306, подключенного к I2C (контакты SDA, SCL)

#define OLED_RESET 4 // Сброс пина № (или -1, если общий пин сброса Arduino)

Adafruit_SSD1306 display (SCREEN_WIDTH, SCREEN_HEIGHT, & Wire, OLED_RESET);

#define NUMFLAKES 10 // Количество снежинок в примере анимации

#define LOGO_HEIGHT 16

#define LOGO_WIDTH 16

static const unsigned char PROGMEM logo_bmp00 9, Bmp002

B00000001, B11000000,

B00000001, B11000000,

B00000011, B11100000,

B11110011, B11100000,

B11111110, B11111000,

B011111000, B11111000,

B011111000, B11111000,

1000,

1000,

B00011011, B10100000,

B00111111, B11100000,

B00111111, B11110000,

B01111100, B11110000,

B01110000, B01110000,

0005

void setup () {

Serial.begin (9600);

// SSD1306_SWITCHCAPVCC = генерировать внутреннее напряжение дисплея из 3,3 В

if (! Display.begin (SSD1306_SWITCHCAPVCC, 0x78)) {// Адрес 0x3D для 128×64

Serial.println (F («SSD1) );

для (;;); // Не продолжать, зацикливаться вечно

}

// Показывать начальное содержимое буфера отображения на экране —

// библиотека инициализирует это с помощью заставки Adafruit.

display.display ();

задержка (2000); // Пауза на 2 секунды

// Очистить буфер

display.clearDisplay ();

// Рисуем белый пиксель

display.drawPixel (10, 10, SSD1306_WHITE);

// Показать буфер дисплея на экране. Вы ДОЛЖНЫ вызывать display () после

// команд рисования, чтобы сделать их видимыми на экране!

display.display ();

задержка (2000);

// дисплей.display () НЕ требуется после каждой отдельной команды рисования,

// если это не то, что вы хотите … скорее, вы можете объединить кучу

// операций рисования, а затем обновить экран сразу, позвонив

// display.display (). Эти примеры демонстрируют оба подхода …

testdrawline (); // Рисуем много линий

testdrawrect (); // Рисуем прямоугольники (контуры)

testfillrect (); // Рисуем прямоугольники (закрашенные)

testdrawcircle (); // Рисуем круги (контуры)

testfillcircle (); // Рисуем круги (закрашенные)

testdrawroundrect (); // Рисуем прямоугольники с закругленными углами (контуры)

testfillroundrect (); // Рисуем прямоугольники с закругленными углами (закрашенные)

testdrawtriangle (); // Рисуем треугольники (контуры)

testfilltriangle (); // Рисуем треугольники (закрашенные)

testdrawchar (); // Рисуем символы шрифта по умолчанию

testdrawstyles (); // Рисуем «стилизованные» символы

testscrolltext (); // Рисуем прокручиваемый текст

testdrawbitmap (); // Нарисовать небольшое растровое изображение

// Инвертировать и восстановить отображение, делая паузу между отображением

.invertDisplay (правда);

задержка (1000);

display.invertDisplay (ложь);

задержка (1000);

testanimate (logo_bmp, LOGO_WIDTH, LOGO_HEIGHT); // Анимировать растровые изображения

}

void loop () {

}

void testdrawline () {

int16_t i;

display.clearDisplay (); // Очистить буфер дисплея

for (i = 0; i

display.drawLine (0, 0, i, display.height () — 1, SSD1306_WHITE);

display.display (); // Обновление экрана с каждой новой нарисованной линией

delay (1);

}

для (i = 0; i

display.drawLine (0, 0, display.width () — 1, i, SSD1306_WHITE);

display.display ();

задержка (1);

}

задержка (250);

display.clearDisplay ();

для (i = 0; i

display.drawLine (0, display.height () — 1, i, 0, SSD1306_WHITE);

display.display ();

задержка (1);

}

для (i = display.height () — 1; i> = 0; i- = 4) {

display.drawLine (0, display.height () — 1, display.width () — 1, i, SSD1306_WHITE);

display.display ();

задержка (1);

}

задержка (250);

display.clearDisplay ();

для (i = display.ширина () — 1; я> = 0; i- = 4) {

display.drawLine (display.width () — 1, display.height () — 1, i, 0, SSD1306_WHITE);

display.display ();

задержка (1);

}

для (i = display.height () — 1; i> = 0; i- = 4) {

display.drawLine (display.width () — 1, display.height () — 1, 0, i, SSD1306_WHITE);

display.display ();

задержка (1);

}

задержка (250);

дисплей.clearDisplay ();

для (i = 0; i

display.drawLine (display.width () — 1, 0, 0, i, SSD1306_WHITE);

display.display ();

задержка (1);

}

для (i = 0; i

display.drawLine (display.width () — 1, 0, i, display.height () — 1, SSD1306_WHITE);

display.display ();

задержка (1);

}

задержка (2000); // Пауза на 2 секунды

}

void testdrawrect (void) {

display.clearDisplay ();

для (int16_t i = 0; i

display.drawRect (i, i, display.width () — 2 * i, display.height ( ) -2 * i, SSD1306_WHITE);

display.display (); // Обновление экрана с каждым новым нарисованным прямоугольником

delay (1);

}

задержка (2000);

}

void testfillrect (void) {

display.clearDisplay ();

для (int16_t i = 0; i

// Используется обратный цвет, поэтому прямоугольники чередуются белым / черным

display.fillRect (i, i, display.width () — i * 2, display.height () — i * 2, SSD1306_INVERSE);

display.display (); // Обновление экрана с каждым новым нарисованным прямоугольником

delay (1);

}

задержка (2000);

}

void testdrawcircle (void) {

display.clearDisplay ();

для (int16_t i = 0; i

display.drawCircle (display.width () / 2, display.height () / 2, i, SSD1306_WHITE);

display.display ();

задержка (1);

}

задержка (2000);

}

void testfillcircle (void) {

display.clearDisplay ();

for (int16_t i = max (display.width (), display.height ()) / 2; i> 0; i- = 3) {

// Используется обратный цвет, поэтому круги чередуются с белым / черный

дисплей.fillCircle (display.width () / 2, display.height () / 2, i, SSD1306_INVERSE);

display.display (); // Обновление экрана с каждым новым нарисованным кругом

delay (1);

}

задержка (2000);

}

void testdrawroundrect (void) {

display.clearDisplay ();

для (int16_t i = 0; i

display.drawRoundRect (i, i, display.width () — 2 * i, display.height () — 2 * i,

display.height () / 4, SSD1306_WHITE);

display.display ();

задержка (1);

}

задержка (2000);

}

void testfillroundrect (void) {

display.clearDisplay ();

for (int16_t i = 0; i

// Используется обратный цвет, поэтому чередующийся белый / черный округляет прямоугольники

display.fillRoundRect (я, я, дисплей.width () — 2 * i, display.height () — 2 * i,

display.height () / 4, SSD1306_INVERSE);

display.display ();

задержка (1);

}

задержка (2000);

}

void testdrawtriangle (void) {

display.clearDisplay ();

для (int16_t i = 0; i

display.drawTriangle (

display.width () / 2 , отображать.height () / 2-i,

display.width () / 2-i, display.height () / 2 + i,

display.width () / 2 + i, display.height () / 2+ i, SSD1306_WHITE);

display.display ();

задержка (1);

}

задержка (2000);

}

void testfilltriangle (void) {

display.clearDisplay ();

for (int16_t i = max (display.width (), display.height ()) / 2; i> 0; i- = 5) {

// Используется обратный цвет, поэтому треугольники чередуются с белым / черный

дисплей.fillTriangle (

display.width () / 2, display.height () / 2-i,

display.width () / 2-i, display.height () / 2 + i,

display.width ( ) / 2 + i, display.height () / 2 + i, SSD1306_INVERSE);

display.display ();

задержка (1);

}

задержка (2000);

}

void testdrawchar (void) {

display.clearDisplay ();

display.setTextSize (1); // Нормальное отображение в масштабе 1: 1 пикселей

.setTextColor (SSD1306_WHITE); // Рисуем белый текст

display.setCursor (0, 0); // Начало в верхнем левом углу

display.cp437 (true); // Используйте полный 256-символьный шрифт «Кодовой страницы 437»

// Не все символы поместятся на дисплее. Это нормально.

// Библиотека будет рисовать все, что может, а остальное будет обрезано.

for (int16_t i = 0; i <256; i ++) {

if (i == ‘\ n’) display.write (»);

еще дисплей.написать (я);

}

display.display ();

задержка (2000);

}

void testdrawstyles (void) {

display.clearDisplay ();

display.setTextSize (1); // Нормальный масштаб пикселей 1: 1

display.setTextColor (SSD1306_WHITE); // Рисуем белый текст

display.setCursor (0,0); // Начало в верхнем левом углу

display.println (F («Hello, world!»));

дисплей.setTextColor (SSD1306_BLACK, SSD1306_WHITE); // Рисуем «инверсный» текст

display.println (3.141592);

display.setTextSize (2); // Рисуем текст в масштабе 2X

display.setTextColor (SSD1306_WHITE);

display.print (F («0x»)); display.println (0xDEADBEEF, HEX);

display.display ();

задержка (2000);

}

void testscrolltext (void) {

display.clearDisplay ();

дисплей.setTextSize (2); // Рисуем текст в масштабе 2X

display.setTextColor (SSD1306_WHITE);

display.setCursor (10, 0);

display.println (F («прокрутка»));

display.display (); // Показать исходный текст

delay (100);

// Прокрутка в разных направлениях с промежуточными паузами:

display.startscrollright (0x00, 0x0F);

задержка (2000);

display.stopscroll ();

задержка (1000);

дисплей.startcrollleft (0x00, 0x0F);

задержка (2000);

display.stopscroll ();

задержка (1000);

display.startscrolldiagright (0x00, 0x07);

задержка (2000);

display.startscrolldiagleft (0x00, 0x07);

задержка (2000);

display.stopscroll ();

задержка (1000);

}

void testdrawbitmap (void) {

display.clearDisplay ();

дисплей.drawBitmap (

(display.width () — LOGO_WIDTH) / 2,

(display.height () — LOGO_HEIGHT) / 2,

logo_bmp, LOGO_WIDTH, LOGO_HEIGHT, 1);

display.display ();

задержка (1000);

}

#define XPOS 0 // Индексы в массив ‘icons’ в функции ниже

#define YPOS 1

#define DELTAY 2

void testanimate (const uint8_t_bitmap, u uint8_t h) {

int8_t f, значки [NUMFLAKES] [3];

// Инициализировать позиции «снежинки»

для (f = 0; f

icons [f] [XPOS] = random (1 — LOGO_WIDTH, display.ширина());

иконок [f] [YPOS] = -LOGO_HEIGHT;

иконок [f] [DELTAY] = случайный (1, 6);

Serial.print (F («x:»));

Serial.print (значки [f] [XPOS], DEC);

Serial.print (F («y:»));

Serial.print (значки [f] [YPOS], DEC);

Serial.print (F («dy:»));

Serial.println (значки [f] [DELTAY], DEC);

}

for (;;) {// Цикл навсегда …

display.clearDisplay (); // Очистить буфер дисплея

// Нарисовать каждую снежинку:

for (f = 0; f

display.drawBitmap (значки [f] [XPOS], значки [f] [YPOS], растровое изображение, w, h, SSD1306_WHITE);

}

display.display (); // Показать буфер отображения на экране

delay (200); // Пауза на 1/10 секунды

// Затем обновим координаты каждой чешуйки …

for (f = 0; f

icons [f] [YPOS] + = icons [f] [DELTAY];

// Если снежинка не в нижней части экрана …

if (icons [f] [YPOS]> = display.height ()) {

// Повторно инициализируем в случайную позицию, сразу за верхними

значками [f] [XPOS] = random (1 — LOGO_WIDTH, display.width ());

значков [f] [YPOS] = -LOGO_HEIGHT;

иконок [f] [DELTAY] = случайный (1, 6);

}

}

}

}

Проекты Arduino — взаимодействие SSD1306 OLED с Arduino

SSD1306 — популярный драйвер дисплея OLED. Портативные и носимые устройства — новые тенденции.Маленькие OLED-дисплеи идеально подходят для таких компактных и портативных устройств. SSD1306 — это однокристальный драйвер CMOS OLED / PLED. Он может управлять точечно-матричным графическим дисплеем 128 × 64. Он предназначен для управления OLED-панелями с общим катодом. Чип имеет несколько встроенных функций, таких как 256-ступенчатая регулировка яркости, оперативная память дисплея, осциллятор и контроль контрастности. Эти встроенные функции сокращают количество необходимых внешних компонентов и делают чип готовым к использованию с любым OLED-экраном совместимого разрешения.

Рисунок 1.Пример SSD1306 OLED

SSD1306 обычно используется в монохроматических OLED-дисплеях с разрешением экрана до 128 × 64. Эти дисплеи теперь являются лучшей альтернативой обычным символьным ЖК-дисплеям. По сравнению с символьными ЖК-дисплеями OLED-дисплеи SSD1306 легко подключаются через I2C или SPI и могут отображать много сложной графики, включая текст, растровые изображения и анимацию. Если сравнивать цены, то небольшие OLED-дисплеи не намного дороже символьных ЖК-дисплеев. Вместо этого OLED-дисплеи намного эстетичны и компактны для использования в носимых и портативных потребительских устройствах.Например, для умных часов символьные ЖК-дисплеи не подходят, а графические ЖК-дисплеи довольно дороги, но небольшой OLED-дисплей идеально подходит для этого.

В этом руководстве мы подключим OLED-дисплей SSD1306 к Arduino с помощью интерфейса SPI. OLED-дисплеи на базе микросхем SSD1306 могут быть подключены к микроконтроллеру или одноплатному компьютеру с помощью I2C, SPI или параллельного интерфейса. Тем не менее, интерфейсы I2C и SPI чаще всего отображаются в виде интерфейсов в модулях OLED-дисплеев.

Необходимые компоненты

1. Ардуино UNO x1
2. 7-контактный SSD1306 OLED-модуль x1
3. Соединительные провода или перемычки

О SSD1306 OLED-дисплее

OLED расшифровывается как Organic Light Emitting Diode.OLED-дисплеи похожи на светодиодные дисплеи, используемые в телевизорах и мониторах. Однако эти дисплеи компактны и подходят для использования в носимых и портативных устройствах. Есть много типов OLED-дисплеев. Эти дисплеи можно классифицировать по размеру, цвету, количеству контактов и микросхеме контроллера. OLED-дисплеи бывают двух распространенных размеров — 0,91 дюйма с разрешением экрана 128 × 32 и 0,96 дюйма с разрешением 128 × 64. Дисплей может быть монохромным синим, монохромным белым или желто-синим цветом. Модуль дисплея OLED может иметь 3-контактный / 4-контактный порт только для интерфейса I2C или 7-контактный интерфейс для 3-проводного интерфейса SPI, 4-проводного интерфейса SPI и интерфейса I2C.SSD1306 и SSD1331 — самые популярные микросхемы драйверов дисплея OLED. В любой модуль OLED-дисплея встроена микросхема контроллера.

В этом проекте мы используем 0,96-дюймовый OLED-дисплей с микросхемой контроллера SSD1306. Модуль имеет желто-синий экран с разрешением экрана 128х64. Используемый здесь модуль имеет 7-контактный интерфейс, позволяющий взаимодействовать с любым микроконтроллером или SBC через 3-проводной SPI, 4-проводный SPI и интерфейс I2C. 4-проводной интерфейс SPI является вариантом интерфейса по умолчанию в 7-контактном модуле.

Как связать SSD1306 OLED с Arduino

7-контактный модуль OLED предлагает все варианты взаимодействия, такие как 3-проводный SPI, 4-проводный SPI и I2C. 4-проводный SPI — это самый быстрый режим связи с OLED, а также режим по умолчанию. 7-контактный OLED-дисплей имеет следующую конфигурацию контактов.

Для сопряжения модуля с Arduino (или любым микроконтроллером или SBC) подключите контакты GND и VCC / VDD к земле и 5V к Arduino соответственно.OLED работает с минимальным энергопотреблением, поэтому не требует внешнего источника питания. Важно отметить, что OLED не включает подсветку просто за счет подачи питания. Никаких изменений на OLED-дисплее не заметно, пока он не будет правильно запрограммирован. Контакты D0, D1, RST, DC и CS могут быть подключены к любому GPIO. 6-контактный модуль не имеет функции Chip Select.

4-контактные модули OLED предлагают только интерфейс I2C для связи с ними.Он имеет следующую конфигурацию контактов.

Для взаимодействия с 4-контактным модулем подключите контакты GND и VCC к земле и 5V к Arduino. Подключите контакты D0 и D1 к любому GPIO.

Подключение цепей

В этом проекте 7-контактный OLED-модуль SSD1306 подключен к Arduino UNO. Модуль подключается к Arduino следующим образом.

Рис. 3 и 4. Дисплей SSD1306 OLED

Программирование дисплея SSD1306 OLED с помощью Arduino

Библиотека для взаимодействия SSD1306 с Arduino доступна от Adafruit.Чтобы найти его, перейдите в диспетчер библиотек Arduino IDE, Sketch -> Включить библиотеку -> Управление библиотеками. Найдите SSD1306 и выберите последнюю версию библиотеки Adafruit SSD1306. Он также загрузит библиотеку GFX как одну зависимость.

Рисунок 5. Установка Adafruit SSD1306 OLED Arduino Library

После включения библиотеку можно импортировать в код, используя следующие строки:

#include
#include

Рабочие примеры библиотеки теперь можно найти в Файл -> Примеры -> Adafruit SSD1306.

Библиотека предоставляет несколько полезных функций. Некоторые из этих часто используемых функций перечислены ниже.

Чтобы преобразовать любое изображение в растровое изображение для отображения на SSD1306 OLED, вы можете использовать следующую ссылку.

Эскиз Arduino

Результат

1.5-дюймовый SMART OLED-модуль для Arduino Projects

1,5-дюймовый микро-OLED-дисплей

uOLED-128G2 — это компактный и экономичный дисплейный модуль, использующий новейшую технологию пассивных матричных OLED (PMOLED) со встроенным графическим процессором GOLDELOX, который обеспечивает «автономную» функциональность для любого проекта.

Мощная графика, текст, изображения, анимация и множество других функций встроены в чип GOLDELOX. Модуль разработан для работы «из коробки», и теперь вы готовы писать свой код на 4DGL (высокоуровневом языке 4D графики), используя 4DGL-Workshop4 IDE (редактор, компилятор и загрузчик).Это сэкономит недели и месяцы на разработке вашего следующего проекта встраиваемой графики.

4DGL — это язык, ориентированный на графику, позволяющий разработчику писать приложения на языке высокого уровня, синтаксис которого аналогичен популярным языкам, таким как BASIC, C и Pascal. Модуль предлагает скромные, но комплексные функции ввода / вывода, которые могут взаимодействовать с последовательным, аналоговым, цифровым, кнопками, джойстиком, генерацией звука и устройствами Dallas 1-Wire.

Этот модуль можно запрограммировать в 3 различных средах в Workshop4 IDE.Дизайнер, ViSi и Serial. Пожалуйста, обратитесь к странице продукта Workshop4 для получения дополнительной информации и документации по этим средам.

Короче говоря, uOLED-128G2 предлагает одно из самых гибких доступных решений для встроенной графики.

uOLED-128-G2-AR включает в себя следующие элементы:

• uOLED-128-G2 Дисплейный модуль

• 4D Arduino Адаптер Shield II

• 5-контактный соединительный кабель розетка-розетка, 150 мм

• 5-контактный переходник папа-папа

• Краткое руководство пользователя доступно для загрузки

Если вы впервые пользуетесь и только начинаете разработку, мы настоятельно рекомендуем приобрести Starter Kit той же модели, так как он включает дополнительные элементы, которые позволят вам немедленно приступить к разработке.

: SK-128G2-AR .

Документация

Программные средства

Модели STEP

Документация процессора GOLDELOX

Библиотеки Arduino

Сопутствующие документы

Grove 128×64 I2C OLED для Arduino и Raspberry Pi — SwitchDoc Labs

Добавление товара в корзину

Это очень читаемый модуль Grove с 4-контактным разъемом I2C OLED.Благодаря высокой контрастности OLED-дисплея он читается даже с мелкими шрифтами. Этот дисплей состоит из 128×64 отдельных белых OLED-пикселей, каждый из которых включается или выключается микросхемой контроллера. Поскольку дисплей излучает собственную подсветку, подсветка не требуется. Это снижает мощность, необходимую для работы OLED. Этот прорыв используется с интерфейсом I2C. Конструкция полностью готова к работе с напряжением 3,3 В / 5 В, со встроенным регулятором и повышающим преобразователем. Подключается к контроллерам Arduino или Raspberry Pi без необходимости в переключателях уровня.Кабель Grove не входит в комплект. Внешний вывод сброса не требуется. Программные драйверы доступны здесь.

Это недорогой I2C OLED-дисплей с разъемами Grove для Arduino / Raspberry Pi / ESP8266

Этот продукт представляет собой очень гибкий модуль Grove с 4-контактным разъемом I2C OLED. Этот дисплей представляет собой OLED-дисплей 128×64, каждый пиксель которого включается или выключается микросхемой контроллера SSD1306, входящей в состав модуля. Вы можете отображать шрифты, графику и даже анимацию на этом четком и высококонтрастном дисплее.

Что такое разъемы Grove?

Grove представляют собой стандартизированные кабели, удобные для подключения и использования для создания прототипов устройств. См. Руководство SwitchDoc по соединителям Grove. Этот продукт был разработан специально для нового кикстартера SwitchDoc Labs, OurWeather: https://www.kickstarter.com/projects/sunair/ourweather-weather-kit-for-stem-kids Этот прорыв разработан для использования с Grove I2C Разъем. Конструкция полностью готова к работе с напряжением 3,3 В / 5 В, со встроенным регулятором и повышающим преобразователем.Подключается к контроллерам ESP8266, Arduino или Raspberry Pi без необходимости в переключателях уровня. Кабель Grove не входит в комплект. Внешний вывод сброса не требуется. У нас есть схема сброса при включении питания. Плату легко подключить к вашей системе. Подключите его к разъему Grove 5 В или 3,3 В на Raspberry Pi, Arduino или ESP8266, и вы готовы к работе. Используемый адрес I2C — 0x3C (а не 0x3D, как некоторые другие дисплеи). Спецификацию SSD1306 можно скачать здесь.

Загрузки

Используйте стрелки влево / вправо для навигации по слайд-шоу или проведите пальцем влево / вправо при использовании мобильного устройства

Сколько тока используют OLED-дисплеи?

Вопросы, на которые я хочу получить ответы:

• Сколько холостого тока потребляется, когда контроллер выключен, по сравнению с включенным (пустой дисплей)?
• Какой минимальный ток позволяет видеть текст в помещении?
• Каков максимальный ток, когда все пиксели горят с максимальной яркостью?
• Как размер дисплея влияет на текущий розыгрыш?
• Как активная запись данных влияет на текущую отрисовку?
• Очевидно, что они используют больше, но сколько тока используют OLED в оттенках серого и в цвете?
• Насколько практичны OLED-дисплеи по сравнению с обычными ЖК-дисплеями для проектов с батарейным питанием?

• Дешевый мультиметр (ручная шкала, предполагаемая точность +/- 10% в худшем случае)
• Различные дисплеи OLED (72×40, 96×16, 128×32, 64×32, 128×64-0.96 дюймов, 128×64-1,3 дюйма)
• Arduino-совместимый микроконтроллер (Adafruit nRF52840 Feather Express)
• Программное обеспечение (моя библиотека ss_oled )

Как насчет цветных и полутоновых OLED-дисплеев?
В Твиттере меня попросили включить быстрый тест этих OLED-дисплеев.Я мог сказать, что потребление энергии было высоким, потому что чип контроллера нагревается на ощупь, когда почти ничего не отображается. У меня больше нет цветного OLED-дисплея SSD1351 для тестирования, но у меня есть 4-битный полутоновый дисплей SSD1327 128×128. Когда дисплей отключен, я измерил 600 мкА. Вот некоторые значения, которые я измерил, когда контраст (яркость) был установлен на максимальное значение:

Дисплей, заполненный цветом 0 — 2,5 мА (каждый пиксель выключен / черный)
Дисплей заполнен цветом 1 — 85 мА
Дисплей заполнен цветом 2 — 111 мА
Дисплей, заполненный цветом 3 — 147 мА
Дисплей, заполненный цветом 15 (сброс дисплея из-за моего 3.Проседание источника питания 3В)

В целом дисплей потребляет намного больше тока для получения такой же яркости пикселей по сравнению с монохромными дисплеями SSD1306.

Процедура:
Я провел 8 различных тестов на каждом дисплее. При настройке «тусклый» контраст установлен на значение 31. Это удобно для чтения при освещении в помещении или ночью. 127 — это контраст по умолчанию, достаточно яркий. 255 — максимальная яркость. Ток измеряли, вставляя щупы мультиметра между Vcc дисплея и 3.Источник питания 3 В (в данном случае регулируемый выход Arduino). Было очень мало видимой разницы между контрастом 1 и 31.

Результат:

. Я думал, что 128×32 было аномалией от конкретного поставщика, но второй дисплей от другого поставщика вел себя точно так же. Как ни странно, второй дисплей 64×32 от того же производителя, купленный той же партией, потреблял вдвое больше энергии, чем протестированный выше.

Я выбрал самый эффективный дисплей для проведения финального теста, который отображает текст (менее 50% покрытия пикселей). Мой амперметр показал 630 мкА для статического текстового дисплея на OLED-экране 64×32.

Выводы:

• Существует почти линейная зависимость между количеством освещенных пикселей и текущим использованием
• Размер дисплея напрямую связан с текущим использованием
• Есть несколько необычных дисплеев, которые потребляют больше тока, чем ожидалось. Необходимо проверить каждую отдельно
• Активная запись на дисплей потребляет больше тока, чем статический дисплей — трудно понять, является ли это активность I2C или микросхема контроллера, или и то, и другое
• Есть что-то странное в моих дисплеях 72×40; Мне нужно будет получить немного у другого поставщика и повторно протестировать
• Вездесущий 128×64 0.96-дюймовые OLED-дисплеи потенциально могут отображать экран, полный полезной информации, при токе менее 5 мА
• Энергопотребление полутоновых и цветных OLED-экранов намного менее эффективно по сравнению с монохромными дисплеями того же размера и яркости.
• Небольшой OLED-дисплей с читаемым в помещении текстом может работать при менее 1 мА

Чтобы ответить на мой последний вопрос о практичности OLED по сравнению с общедоступными ЖК-дисплеями для проектов с батарейным питанием, я думаю, что это зависит от проекта и источника питания. ЖК-дисплей приличного размера с выключенной подсветкой может потреблять менее 275 мкА (мои измерения для 2-дюймового 128×64 UC1701). Если у вас небольшой бюджет мощности и ваш MCU запрограммирован на спящий режим большую часть времени (средний ток <1 мА), это может имеют огромное значение по сравнению с OLED-дисплеем 5-20 мА, отображающим ту же информацию. С другой стороны, если вы включаете Raspberry Pi Zero или ESP32 с WIFI (80-120 мА), еще 5-20 мА не сработают. такая же большая разница в вашем бюджете мощности.

цветных OLED-экранов Arduino — дисплей Newhaven Intl

Избавьтесь от длительного времени на разработку цветных OLED-экранов с помощью цветных OLED-экранов Arduino Shields от Newhaven Display International. Доступные в трех размерах, эти щиты готовы к работе с некоторыми из наиболее часто используемых плат разработки Arduino. В дополнение к этим цветным OLED-экранам доступны стандартные готовые цветные OLED-модули, позволяющие легко разрабатывать с более чем одним размером.Цветные OLED-экраны Arduino от Newhaven Display разработаны с учетом потребностей инженеров всех уровней, желающих усовершенствовать свой текущий проект с помощью более совершенной технологии отображения с низким энергопотреблением.

Цветные OLED-дисплеи Arduino Shields предлагают инженерам любого уровня доступный и эффективный способ начать разработку с помощью цветных OLED-дисплеев Newhaven Display. Эти экраны помогают сократить разрыв между всеми типами пользователей, поскольку они просты в использовании, быстро выводятся на рынок, доступны по цене и являются частью большого инженерного сообщества.Цветные OLED-экраны Arduino Shield предназначены не только для инженеров, они являются идеальным инструментом для обучения различным аспектам разработки дисплеев и могут быть легко адаптированы к условиям учебной аудитории. Эти щиты, разработанные инженерами для инженеров, готовы воплотить любую идею в жизнь.

Видео : Учебное пособие по цветному OLED-дисплею Arduino Shield