Zaloguje się
or
Tel +48 698 615 740

WYŚWIETLACZE OLED 0.91, 0.96

28 października, 2021

W tym artykule omówimy Wyświetlacze OLED 0.91, 0.96 krok po kroku pokażemy jak w łatwy sposób można go wykorzystywać w swoich projektach DIY. Zaprezentujemy Biblioteki Które są potrzebne do obsługi tych wyświetlaczy a także napiszemy prosty program prezentujący możliwości Wyświetlacza.

Spis Treści

  • Krótki Opis Wyświetlaczy
  • Specyfikacja
  • Prawidłowe podłączenie Wyświetlacza do Arduino
  • Wgranie własnej Grafiki
  • Pliki do Pobrania

Krótki Opis Wyświetlaczy

Wyświetlacze OLED dostępne są w dwóch rozmiarach 0,91″ rozdzielczości 128 x 64 px i 0,96” i o rozdzielczości 128 x 32px Ekran oparty na sterowniku SH1106 pracuje z napięciami 3,3 V oraz 5 V, komunikuje się poprzez I2C. Posiada wlutowane proste złącza goldpin. Współpracuje m.in. z płytkami Arduino. Wyświetla znaki w kolorze niebieskim, białym lub żółtym zależnie od wersji

Specyfikacja

  • Napięcie pracy: od 3,3 V do 5,0 V
  • Sterownik: SH1106 (dokumentacja)
  • Komunikacja: I2C
  • Typ wyświetlacza: OLED
  • Przekątna: 0,96″ lub 0,91”
  • Rozdzielczość: 128 x 64 px lub 128 x 32
  • Kolor znaków: biały żółty, niebieski (zależne do modelu)
  • Kąt widzenia: powyżej 160 °
  • Temperatura pracy: od -20 °C do 70 °C
  • Wymiary: 35 x 33 mm lub 22 x 11 mm

Prawidłowe podłączenie Wyświetlacza do Arduino

Oba wyświetlacze podłącza się tak samo, więc nie powinno być problemu, ponieważ połączenie ich jest bardzo łatwe. Prawidłowe podłączenie Wyświetlaczy przedstawimy wykorzystując do tego celu Arduino Nano. Tak więc obracamy naszą płytkę Arduino Nano i na spodzie szukamy oznaczenia SCL oraz SDA, będą nam one potrzebne do podłączenia naszego wyświetlacza. Teraz szukamy na naszym wyświetlaczu OLED takiego samego oznaczenia, kiedy znajdziemy łączymy odpowiednio SCL do SCL, SDA do SDA, ostatnie co zostało nam do zrobienia to zasilanie oraz uziemienie. Wyprowadzenie VCC na wyświetlaczu łączymy z 5V oraz GND do GND na Arduino, to będzie na tyle z połączenia, całość można wykonać bezpośrednio do Arduino, albo wykorzystując do tego płytkę stykową tak jak na poniższym schemacie.

Instalacja potrzebnych bibliotek

Zaczniemy od pobrania potrzebnych bibliotek, wszystkie są dostępne do pobrania tutaj (jeżeli nie wiesz jak zaimportować odsyłam tutaj):

  • I2CScanner – pozwoli na sprawdzenie numeru naszego wyświetlacza
  • Adafruit_SSD1306 – służy do obsługiwania wyświetlacza
  • Adafruit GFX Library – będzie potrzebna, gdy będziemy chcieli użyć grafik
  • Adafruit_BusIO – potrzebna do działania powyższych bibliotek

Po wykonaniu połączenia, oraz pobraniu bibliotek należy sprawdzić adres I2C które pozwala na komunikację między ekranem, a Arduino, będzie to niezbędne, aby nasz ekran działał prawidłowo. Aby sprawdzić adres wystarczy wykorzystać przykład z biblioteki I2CScanner, zrobimy to w następujący sposób.

Przechodzimy do programu Arduino, klikamy plik → przykłady → I2CScanner i wybieramy Scanner

Następnie kompilujemy i wgrywamy program, po wgraniu włączamy monitor portu szeregowego i odczytujemy nasz numer

W moim przypadku będzie to 0x3C, zapisujemy gdzieś nasz adres, ponieważ przyda nam się w dalszej części.

Jeżeli posiadamy ekran 128×64(jak posiadasz ekran 128×32 pomiń ten etap), będziemy musieli edytować naszą bibliotekę, przechodzimy do miejsca przechowywania bibliotek, domyślnie jest to C:\Users\nazwa_użytkownika\Documents\Arduino\libraries

Szukamy folderu o nazwie Adafruit_SSD1306, następnie wybieramy Adafruit_SSD1306.h i edytujemy plik, teraz za komentujemy poniższą linijkę dodając „//” przed nią

//#define SSD1306_128_64 /// DEPRECTAED: old way to specify 128x64 screen

Następnie od komentujemy linijkę wyżej usuwając „//” z przodu

#define SSD1306_128_64 /// DEPRECTAED: old way to specify 128x64 screen

Zapisujemy i teraz nasz ekran będzie wyświetlał prawidłowo, jeżeli będziecie chcieli zmienić ekran na 128×32 robicie to samo, tylko na odwrót.

Skoro ekran został ustawiony prawidłowo, znamy już jego numer, możemy zabrać się do przetestowania czy wyświetlacz działa i wyświetla tekst. Skorzystamy z przykładu zawartego w bibliotece Adafruit_SSD1306, wybieramy ten odpowiadający wielkości naszego ekranu tak jak na poniższym screenie. Ja wybiorę ssd1306_128x64_i2c ponieważ korzystam z wyświetlacza o wielkości 128×64.

Sprawdzamy czy adres zgadza się z naszym

W moim wypadku się nie zgadzał, więc zmieniam na poprawny. Kompilujemy i wgrywamy do Arduino, istnieje też możliwość, że program nam się nie skompiluje i będziemy potrzebować wgrać dodatkową bibliotekę Adafruit_VEML6075 która powinna rozwiązać ten problem. Jeżeli wszystko jest w porządku powinniśmy ujrzeć na naszym ekranie grafiki testowe od Adafruit. Jeżeli nie, sprawdźcie dokładnie połączenie, oraz czy macie wszystkie potrzebne biblioteki.

Skoro wiemy, że nasz ekran już działa, wykorzystajmy to, napiszmy program który pozwoli nam na wyświetlenie na nim tekstu, który będzie się zmieniał co sekundę.

Zaczniemy od implementacji bibliotek

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

Tworzymy obiekt display

Adafruit_SSD1306 display(0);

W funkcji setup ustawiamy rodzaj wyświetlacza, oraz nasz numer I2C, czyścimy ekran, ustawiamy czcionkę

void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);//definiujemy rodzaj użytego wyświetlacza oraz adres I2C
  display.clearDisplay();//czyścimy ekran
  display.setTextSize(3);// ustawiamy rozmiar czcionki
  display.setTextColor(WHITE);//ustawiamy kolor biały
}

W funkcji loop wyświetlamy tekst na ekranie, pierwszy parametr ustawienia kursora odpowiada za szerokość, a drugi za wysokość, musimy pamiętać o display.display(), aby wyświetlić coś na naszym ekranie, bez tego się nic nie wydarzy, równie ważna jest funkcja display.clearDisplay() która czyści nasz ekran, bez niej tekst nakładał by się na siebie.

void loop() {
  display.setCursor(2, 24);//ustawiamy kursor na pozycje 2 szerokości, 16 wysokości (w wypadku wyświetlacza 128x32 ustawiamy 2,6)
  display.println("AJMAKER");//piszemy tekst który ma się ukazać
  display.display();//wyświetlamy na ekranie, bez tego nie zadziała
  
  display.clearDisplay();
  delay(1000);
  
  display.setCursor(32, 24);//ustawiamy kursor na pozycje 32, 16 (w wypadku wyświetlacza 128x32 ustawiamy 32,6)
  display.println("BLOG");//piszemy tekst który ma się ukazać
  display.display();//wyświetlamy na ekranie, bez tego nie zadziała

  display.clearDisplay();
  delay(1000);
}

Po wgraniu i skompilowaniu programu napis na naszym wyświetlaczu powinien się zmieniać.

Wyświetlanie własnych grafik

Kiedy skończymy konfigurowanie naszego wyświetlacza, oraz wyświetlimy tekst, chcielibyśmy zrobić coś więcej, tak jak na przykład wyświetlenie własnej grafiki. Możemy to zrobić z pomocą biblioteki którą wcześniej pobraliśmy, oraz specjalną stroną która prze-konwertuje naszą grafikę na kod który pozwoli później wyświetlić go na ekranie. Zaczniemy od pobrania jakiejś grafiki z internetu, w moim przypadku będzie to serduszko bez wypełnienia, na początku będzie trzeba zmienić jego wymiary na takie jakie posiada nasz wyświetlacz u mnie jest to 128×64, więc do takich wymiarów go przeskaluję, wystarczy nam do tego paint, oczywiście jeżeli posiadamy bardziej zaawansowany program np. gimp, czy photoshop możemy go wykorzystać. Wrzucamy nasz plik do edytora grafiki i wpisujemy następująco interesujące nas wartości.

Po takim zabiegu nasza grafika jest gotowa do zamienienia jej na kod. Tak więc wchodzimy tutaj https://javl.github.io/image2cpp/ wgrywamy naszą grafikę i ustawiamy następujące parametry

Tam gdzie kolor zielony, zaznaczamy kolor tła które ma nasz obrazek, następnie tam gdzie kolor pomarańczowy zaznaczamy tą opcję, kolor fioletowy odpowiada za ustawienie widoczności naszego obrazka, także musimy patrzeć na Preview i kiedy stanie się wystarczająco widoczny, możemy przejść dalej.

Ustawiamy tak jak poniżej i klikamy Generate code.

Następnie skopiowany kod umieszczamy w tym napisanym prze ze mnie

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

Adafruit_SSD1306 display(0);

void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);//definiujemy rodzaj użytego wyświetlacza oraz adres I2C
  display.clearDisplay();//czyścimy ekran
}

//tutaj umieść swój kod obrazka


void loop() {
  display.drawBitmap(0, 0, nazwa, 128, 64, WHITE);//pierwsze dwa parametry odpowiadają za ustawienie kursora, nazwa oznacza nazwę naszego kodu obrazka, a 128 i 64 to rozmiar obrazka, na końcu ustawiamy kolor WHITE czyli biały
  display.display();//wyświetlamy na ekranie, bez tego nie zadziała
}

Pod komentarzem wklejamy swój kod obrazka ze strony, następnie patrzymy na to jak się nazywa

podmieniamy nazwę, na naszą i przesyłamy kod do Arduino, jeżeli wszystko zrobiliśmy prawidłowo powinniśmy ujrzeć naszą grafikę na wyświetlaczu.

Dla tych co nie potrzebują tak dużej grafiki mogą zmienić jej rozmiar przykładowo na 32×16, wystarczy tylko wgrać taką grafikę na stronę, wygenerować kod i zamienić w programie 128, 64 na 32, 16. Wyglądało by to w ten sposób display.drawBitmap(0, 0, nazwa, 32, 16, WHITE); jeżeli chcemy możemy wyświetlić grafikę w dowolnym miejscu, aby to zrobić zmieniamy ustawienie kursora display.drawBitmap(32 – szerokość, 24 – wysokość, nazwa, 32, 16, WHITE);

Pliki do pobrania

Sticky
Możliwość komentowania WYŚWIETLACZE OLED 0.91, 0.96 została wyłączona
Adrian Wojtala

Adrian Wojtala

Ma 21 lat. Studiuje informatykę na Uniwersytecie DSW, ukończył technikum o profilu technik-informatyk. Interesuje się programowaniem i w przyszłości ma plan zostać back-end developerem. Swoją przygodę z Arduino rozpoczął podczas praktyk od września 2021 r.

Comments are closed.

Strona korzysta z plików cookies w celu realizacji usługi i zgodnie z Polityką Plików Cookies. Możesz określić warunki przechowywania lub dostępu do plików cookies w Twojej przeglądarce.