Zabawa z wyświetlaczem OLED i Arduino: 12 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:28

Jestem prawie pewien, że na pewno słyszałeś o technologii wyświetlania OLED. Jest stosunkowo nowy i oferuje lepszą jakość niż stara technologia LCD. W tym samouczku chcemy omówić kroki wymagane do wyświetlania danych na jednym z najpopularniejszych jednokolorowych modułów wyświetlacza OLED dostępnych na rynku. Postaram się wyjaśnić funkcjonalności dostarczane przez odpowiednią bibliotekę Adafruit do wyświetlania danych w tym module.

Krok 1: Z jakich modułów OLED będziemy korzystać?

Moduły OLED są dostępne w szerokiej gamie rozmiarów i funkcji. Ten, którego użyjemy w tym samouczku, to monokolorowy moduł OLED 128x64. Ten typ modułu dostępny jest w następujących rozmiarach (tak jak widać na zdjęciach):

• 128x64
• 128x32
• 96x16
• 64x48
• 64x32

Ponieważ wszystkie te moduły obsługują protokół I2C jako środek komunikacji, ich kod i okablowanie są dokładnie takie same. Jedyną różnicą jest to, że musisz wziąć pod uwagę rozmiar wyświetlacza w swoim kodzie, aby zawartość, którą zamierzasz wyświetlić, pasowała do niego prawidłowo.

Krok 2: I2C w pigułce

Układ scalony (IIC), który jest zwykle nazywany I2C (I do kwadratu C), opracowany przez firmę Philips w latach 80. jako magistrala wymiany danych używana do przesyłania danych między jednostką centralną (CPU) lub jednostką mikrokontrolera (MCU) urządzenia i chipy peryferyjne. Zasadniczo był przeznaczony do zastosowań telewizyjnych. Dzięki swojej prostocie stał się tak popularny, że po pewnym czasie stał się jednym z podstawowych mechanizmów przesyłania danych dla procesorów i MCU oraz urządzeń peryferyjnych, które nie są koniecznie częścią tej samej płytki PCB i są z nią połączone przewodowo (np. czujniki, moduły wyświetlacza itp.).

I2C składa się z dwuprzewodowej magistrali komunikacyjnej, która obsługuje dwukierunkowy transfer danych między urządzeniem nadrzędnym a kilkoma urządzeniami podrzędnymi. Zazwyczaj węzeł nadrzędny odpowiada za sterowanie magistralą – co faktycznie odbywa się poprzez generowanie sygnału synchronizacji na szeregowej linii zegarowej (SCL). Jest to sygnał, który byłby przesyłany w sposób ciągły przez mastera podczas transferu, a wszystkie inne węzły podłączone do magistrali będą go używać do synchronizacji komunikacji i wykrywania prędkości magistrali. Dane są przesyłane między urządzeniem nadrzędnym i podrzędnym za pośrednictwem linii danych szeregowych (SDA). Szybkość transmisji może wynosić do 3,4 Mb/s. Wszystkie urządzenia, które chcą przesyłać dane przez I2C, powinny mieć unikalny adres i mogą działać jako nadajnik lub odbiornik w zależności od funkcji urządzenia. Na przykład moduł wyświetlacza OLED to odbiornik, który przyjmuje pewne dane i wyświetla je, podczas gdy czujnik temperatury to nadajnik-odbiornik, który przesyła zmierzoną temperaturę przez magistralę I2C. Zwykle urządzenie nadrzędne to urządzenie, które inicjuje transmisję danych w magistrali i generuje sygnały zegarowe umożliwiające transmisję. Podczas tego transferu każde urządzenie zaadresowane przez ten master jest uważane za urządzenie podrzędne i odczytuje te dane.

Kiedy węzeł chce wysłać jakieś dane, pierwszy bajt danych powinien być adresem odbiorcy, a dopiero potem pojawiają się rzeczywiste dane. Oznacza to, że aby przesłać dane do urządzenia wyjściowego za pomocą I2C (np. moduł wyświetlacza I2C OLED) powinniśmy najpierw znaleźć jego adres I2C i to właśnie zrobimy w kolejnych krokach.

Jeśli chcesz dowiedzieć się więcej o szczegółach i teoriach dotyczących magistrali I2C, możesz skorzystać z następujących referencji:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Krok 3: Wymagane moduły i komponenty

Tutaj znajdziesz listę komponentów potrzebnych do ukończenia tego samouczka:

Łącza do serwisu eBay:

• 1 x Arduino Uno:
• 1 x moduł OLED 128x64:
• 4 x kabel Dupont:
• 1 x Mini płytka stykowa bez lutowania:

Linki Amazon.com:

• 1 x Arduino Uno:
• 1 x moduł OLED 128x64:
• 4 x kabel Dupont:
• 1 x płytka stykowa bez lutowania:

Krok 4: Podłączanie modułu wyświetlacza OLED do Arduino

Ważną uwagą dotyczącą urządzeń obsługujących I2C jest to, że sposób, w jaki należy je podłączyć do Arduino, jest taki sam. Dzieje się tak, ponieważ Arduino uruchamia komunikację I2C tylko na określonych pinach. W tym tutorialu używam Arduino Uno. Arduino Uno wykorzystuje pin A5 jako SCK i A4 jako SDA. Możemy więc podłączyć moduł wyświetlacza OLED do Arduino Uno, jak pokazano na schematycznym widoku. Jak możesz zauważyć na zdjęciu, które zrobiłem z mojego modułu wyświetlacza OLED, złącze VCC i GND jest inne niż na schemacie. Pamiętaj, aby sprawdzić etykiety pinów na swoich modułach, aby upewnić się, że podłączasz je we właściwy sposób.

Potrzebujemy tylko 4 pinów, które należy połączyć jak poniżej:

Arduino VCC -> Moduł OLED VCC

Arduino GND -> Moduł OLED GND

Arduino 4 -> Moduł OLED SDA

Arduino 5 -> Moduł OLED SCK

Krok 5: Znajdowanie adresu modułu wyświetlacza

Pierwszym krokiem do połączenia z urządzeniem obsługującym I2C jest posiadanie adresu modułu. W tym celu, po podłączeniu modułu do Arduino, wystarczy wgrać załączony kod do Arduino. Ten kod zawiera bibliotekę Wire, która jest biblioteką dołączoną do Arduino IDE, która obsługuje komunikację I2C. Próbuje skanować podłączone urządzenia I2C i wysyła ich adresy przez port szeregowy do twojego komputera. Możesz więc uzyskać dostęp do jego wyjścia za pomocą narzędzia Serial Monitor w Arduino IDE. Oryginalna wersja jest dostępna w Arduino Playground). Możesz go również wyświetlić w bardziej czytelny sposób w moim internetowym edytorze Arduino. Nie oczekuj, że cokolwiek zostanie wyświetlone na ekranie podczas działania tego kodu.

Jak widać na obrazku, mój moduł jest powiązany z adresem 0x3C. Zwykle wszystkie urządzenia w określonej linii produktów (na przykład wszystkie moduły OLED 128x64) mają ten sam adres.

Adresy urządzeń I2C są ograniczone od 1 do 126. Ten kod po prostu próbuje połączyć się z każdym urządzeniem w kolejności (bez przesyłania jakichkolwiek danych), a następnie sprawdza, czy nie wystąpił błąd zgłoszony przez bibliotekę podstawową podczas łączenia się z podanym adresem. Jeśli nie ma błędu, wyświetla adres jako dostępny moduł do połączenia. Należy również zauważyć, że pierwsze 15 adresów jest zarezerwowanych, więc przeskakuje je i wyświetla tylko te powyżej tego zakresu. Pamiętaj, że adres tych modułów I2C jest na stałe zakodowany w urządzeniu i nie można go zmienić. Dlatego dobrym pomysłem byłoby zapisanie go gdzieś lub umieszczenie etykiety na module, gdy zamierzasz odłożyć go z powrotem na półkę laboratoryjną, aby następnym razem uruchamianie kodu skanera nie było konieczne. Nie jest to jednak skomplikowana procedura;)

Krok 6: Instalowanie bibliotek wymaganych do wyświetlania danych na module OLED

Biblioteka Wire może obsługiwać komunikację niskiego poziomu z urządzeniami I2C. Kiedy chcesz połączyć się z konkretnym urządzeniem w celu odczytania/zapisania danych z/do niego, normalnie użyjesz biblioteki dostarczonej przez firmę, która oryginalnie zbudowała ten moduł. Biblioteka ta obsługuje wszystkie szczegóły komunikacji I2C z danym modułem i pozwala nam bardziej skoncentrować się na naszej działalności, czyli w tym przypadku wyświetlaniu danych w taki sposób, jak chcemy.

Adafruit, firma produkująca oryginalną wersję takich modułów wyświetlaczy, udostępnia biblioteki o nazwie Adafruit SSD1306 do wyświetlania danych na tych monochromatycznych wyświetlaczach. Dlatego przed rozpoczęciem kodowania musimy zainstalować tę bibliotekę za pomocą Menedżera bibliotek (dostępnego w menu Szkic> Dołącz bibliotekę> Zarządzaj bibliotekami…) w Arduino IDE. Istnieje również inna biblioteka o nazwie Adafruit GFX Library, która obsługuje bardziej niskopoziomowe elementy graficzne i jest używana wewnętrznie przez Adafruit SSD1306. Musisz mieć oba z nich zainstalowane na swoim Arduino IDE, jak widać na zdjęciach.

Krok 7: Inicjalizacja modułu wyświetlacza

Moduł rysowania na wyświetlaczu jest opakowany w klasę o nazwie Adafruit_SSD1306. Definicja tej klasy znajduje się w bibliotece Adafruit, więc najpierw musimy uwzględnić tę bibliotekę. Następnie musimy najpierw utworzyć instancję tej klasy. Konstruktor tej klasy pobiera numer portu, na którym można zresetować wyświetlacz, czyli pin 4 (podłączony do SCK). Ta część kodu powinna znajdować się na początku pliku (poza funkcjami setup() i loop()).

#włączać

Wyświetlacz Adafruit_SSD1306(4);

Teraz wewnątrz funkcji setup() powinniśmy wywołać funkcję begin obiektu wyświetlanego, przekazując nasz adres I2C jak poniżej (SSD1306_SWITCHCAPVCC jest wartością stałą określającą typ źródła zasilania biblioteki):

pusta konfiguracja () {

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.display(); } void loop() {} // pętla może być na razie pusta

Teraz obiekt wyświetlany jest gotowy i możemy wywoływać jego funkcje (np. display.write(), display.drawLine itp.). Ważną uwagą jest to, że za każdym razem, gdy coś rysujemy, wywołując nasz obiekt wyświetlany, musimy wywołać funkcję display.display(), aby faktyczne rysowanie odbywało się na poziomie sprzętowym. Wynika to głównie z faktu, że funkcje rysowania, które wywołujemy, po prostu aktualizują reprezentację wyświetlacza „w pamięci” ze względów wydajnościowych. W rzeczywistości buforuje zmiany w pamięci. Powinniśmy więc zawsze pamiętać o wywołaniu funkcji display(), gdy skończymy rysować coś na ekranie.

wyświetl.zapis(…); // aktualizuje się w pamięci

wyświetl.rysujLinię(…); // stale aktualizuje się w pamięci. display.display(); // opróżnia wszystkie zmiany w sprzęcie wyświetlającym

Jeśli spróbujesz przesłać swój kod w tym kroku, zauważysz, że zostanie wyświetlone logo Adafruit Industries. Możesz się zastanawiać, kto poprosił go o narysowanie tego! Właściwie to właśnie robi biblioteka Adafruit. Inicjuje pamięć modułu (reprezentację w pamięci sprzętu wyświetlającego) z logo tej firmy. Jeśli nie chcesz tego widzieć podczas inicjalizacji, możesz spróbować wywołać funkcję display.clearDisplay() tuż przed wywołaniem display.display() w funkcji konfiguracji. Ta funkcja, jak sama nazwa wskazuje, całkowicie czyści wyświetlacz.

#włączać

Wyświetlacz Adafruit_SSD1306(4); void setup() { display.begin(SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay(); display.display(); } void loop() { }

Bazując na dokumentacji biblioteki Adafruit_SSD1306, można używać różnych funkcji dostarczanych przez tę klasę do rysowania na wyświetlaczu lub bezpośredniej manipulacji na nim pikselami. W kolejnych sekcjach postaramy się przedstawić przykład dla każdego z nich, abyś miał pojęcie o tym, jak to działa. Większość z tych przykładów wyświetla tylko prostą zawartość statyczną, więc możemy po prostu umieścić je w naszej funkcji setup() (po kodzie inicjującym). W ten sposób zostałaby uruchomiona tylko raz i tam pozostanie.

Krok 8: Wyświetl prosty tekst

Aby wyświetlić tekst, możemy użyć prostej funkcji display.println() biblioteki. Akceptuje tekst jako ciąg i próbuje go wyświetlić. Ważne jest, aby wiedzieć, że musimy powiedzieć bibliotece, gdzie na wyświetlaczu zamierzamy zaprezentować tekst. Każdy piksel na wyświetlaczu ma współrzędną określoną za pomocą X i Y. X rośnie od lewej do prawej, a Y rośnie od góry do dołu. Lewy górny róg ekranu to (X=0, Y=0), a prawy dolny róg to (X=127, Y=63). Na pierwszym zdjęciu zanotowałem współrzędne rogów. Możemy użyć funkcji display.setCursor(), aby określić, gdzie na ekranie będziemy wyświetlać tekst.

Kolejną właściwością tekstu jest jego kolor. Możemy określić kolor za pomocą metody display.setTextColor(), jak pokazano na poniższym przykładzie.

display.clearDisplay();

display.setTextColor (BIAŁY); display.setCursor(35, 30); display.println("Witaj świecie!"); display.display();

Możemy również użyć funkcji display.write(), aby wyświetlić pojedynczy znak. Akceptuje kod znaku jako typ uint8_t i wyświetla znak odpowiadający temu kodowi w ciągu. Na przykład, jeśli chcemy wyświetlić ten sam ciąg za pomocą tej funkcji, możemy użyć następującego fragmentu:

display.clearDisplay();

display.setTextColor (BIAŁY); display.setCursor(35, 30); wyświetl.zapis(72); display.write(101); wyświetl.zapis(108); wyświetl.zapis(108); display.write(111); wyświetl.zapis(32); wyświetl.zapis(87); display.write(111); display.write(114); wyświetl.zapis(108); wyświetl.zapis(100); wyświetl.zapis(33); display.display();

Możliwe jest również rysowanie tekstów w kolorze czarnym z białym tłem. W tym celu należy wywołać funkcję display.setTextColor jak poniżej:

display.clearDisplay();

// Ustawia kolor na czarny z białym tłem display.setTextColor(BLACK, WHITE); display.setCursor(25, 30); display.println("Odwrócony tekst!"); display.display();

Masz również możliwość ustawienia rozmiaru tekstu za pomocą funkcji display.setTextSize(). Jako rozmiar przyjmuje liczbę całkowitą. Im większa liczba, tym większy byłby tekst. Najmniejszy rozmiar to 1, który jest domyślnym rozmiarem tekstów. Poniższy kod próbuje napisać literę „A” w 6 różnych rozmiarach:

display.clearDisplay();

display.setTextColor (BIAŁY); display.setCursor(0, 0); display.setTextSize(1); display.print("A"); display.setTextSize(2); display.print("A"); display.setTextSize(3); display.print("A"); display.setTextSize(4); display.print("A"); display.setTextSize(5); display.print("A"); display.setTextSize(6); display.print("A"); display.display();

Krok 9: Rysowanie podstawowych kształtów

Rysowanie podstawowych kształtów, takich jak prostokąt, okrąg, trójkąt, linia lub punkt, jest bardzo łatwe i dla każdego z nich jest dedykowana funkcja.

Rysowanie linii

Aby narysować linię, możesz wywołać display.drawLine(startX, startY, endX, endY, color). Na przykład poniższy kod rysuje na ekranie ukośne linie, które tworzą duży X:

display.clearDisplay();

display.drawLine(0, 0, display.width() - 1, display.height() - 1, BIAŁY); display.drawLine(display.width() - 1, 0, 0, display.height() - 1, BIAŁY); display.display();

Dostęp do szerokości i wysokości wyświetlacza można uzyskać za pomocą funkcji display.width() i display.height(). Dzięki temu Twój kod byłby niezależny od rozmiaru ekranu.

Rysowanie prostokąta

Funkcją rysowania prostokąta jest display.drawRect(upperLeftX, upperLeftY, szerokość, wysokość, kolor). Oto kod, który rysuje trzy prostokąty w losowych miejscach:

display.clearDisplay();

display.drawRect(100, 10, 20, 20, BIAŁY); display.fillRect(10, 10, 45, 15, BIAŁY); display.drawRoundRect(60, 20, 35, 35, 8, BIAŁY); display.display();

Wywołując display.fillRect(upperLeftX, upperLeftY, width, height, WHITE) możesz narysować prostokąt wypełniony określonym kolorem. Również trzecią funkcją w tym przykładzie jest display.drawRoundRect(upperLeftX, upperLeftY, width, height, cornerRadius, color), która, jak widać na rysunku, służy do rysowania prostokąta z zaokrąglonymi rogami. Akceptuje dodatkowy parametr przed kolorem, który jest liczbą całkowitą wskazującą promień narożnika. Im większa wartość, tym zaokrąglony róg. Ma również odpowiednią funkcję wypełniania o nazwie display.drawFillRoundRect, którą myślę, że możesz zgadnąć, co robi.

Koło do rysowania

Funkcja to display.drawCircle(centerX, centerY, radius, color). Oto przykład, który rysuje kształt przypominający buźkę:

display.drawCircle(60, 30, 30, BIAŁY);

display.fillCircle(50, 20, 5, BIAŁY); display.fillCircle(70, 20, 5, BIAŁY);

Podobnie jak w przypadku prostokątów, możesz użyć funkcji display.fillCircle, aby narysować okrąg wypełniony danym kolorem.

Trójkąt rysunkowy

Ach, znowu funkcja o nazwie display.drawTriangle(poin1X, point1Y, point2X, point2Y, point3X, point3Y, kolor) i odpowiedni display.fillTriangle, które rysują wypełniony trójkąt.

display.drawTriangle(24, 1, 3, 55, 45, 55, BIAŁY);

display.fillTriangle(104, 62, 125, 9, 83, 9, BIAŁY);

Narysuj punkt

Możesz także pokolorować określony punkt (nazywany pikselem) na ekranie za pomocą funkcji display.drawPixel(pixelX, pixelY, color).

display.drawPixel(20, 35, BIAŁY);

display.drawPixel(45, 12, BIAŁY); display.drawPixel(120, 59, BIAŁY); display.drawPixel(97, 20, BIAŁY); display.drawPixel(35, 36, BIAŁY); display.drawPixel(72, 19, BIAŁY); display.drawPixel(90, 7, BIAŁY); display.drawPixel(11, 29, BIAŁY); display.drawPixel(57, 42, BIAŁY); display.drawPixel(69, 34, BIAŁY); display.drawPixel(108, 12, BIAŁY);

Krok 10: Rysowanie obrazu

Rysowanie obrazu jest inne i nieco skomplikowane. Ponieważ moduł wyświetlania jest monokolorowy, musimy najpierw przekonwertować nasz obraz do formatu zwanego bitmapą monokolorową (zwaną również czarno-białą). W takim formacie każdy piksel obrazu ma wartość 0 lub 1. Cyfra 1 oznacza istnienie koloru, a 0 oznacza pustą przestrzeń. Możesz zobaczyć przykład logo Arduino w tym formacie na górze tej sekcji. Funkcją rysowania obrazu bitmapowego jest display.drawBitmap(topLeftX, topLeftY, imageData, szerokość, wysokość, kolor). Parametr imageData to tablica liczb w bajtach. Każdy bajt ma 8 bitów, więc każdy bajt zawiera dane 8 pikseli obrazu. Określając szerokość i wysokość obrazu, funkcja drawBitmap będzie wiedziała, od którego bitu zaczyna się kolejny rząd pikseli.

Rozwiązaniem, które wybrałem do przekonwertowania mojego obrazu do tego formatu, było najpierw użycie jednego z internetowych "konwerterów obrazu na ASCII" (np. https://my.asciiart.club) do przekonwertowania mojego obrazu na zestaw znaków ASCII, a następnie zastąpienie znaki używane do pustej przestrzeni o 0, a inne o 1. To właśnie widzisz poniżej. Możesz myśleć o każdym 0 i 1 jako pikselu na wyświetlaczu. Tak więc rozmiar obrazu nie powinien przekraczać naszego rozmiaru wyświetlacza, który wynosi 128x64.

Uwaga: Korzystanie z tej techniki ASCII nie jest zalecanym podejściem, ponieważ ze względu na proporcje znaków obraz zostanie zdeformowany (znaki nie są kwadratami). Wypróbowałem tę technikę tylko dlatego, że ułatwia ona konwersję obrazu do wymaganego formatu. W przeciwnym razie możliwe byłoby osiągnięcie najlepszego wyniku poprzez programowanie lub użycie niektórych aplikacji użytkowych, które są całkowicie poza zakresem tego tekstu.

00000000000000000000011111111111111111111110000000000000000000000000000000000000011111111111111111111111111111100000000000000000 0000000000000111111111111111111111111111111111111110000000000000 0000000000011111111111111111111111111111111111111111100000000000 0000000001111111111111111111111111111111111111111111111000000000 0000000111111111111111111111111111111111111111111111111110000000 0000011111111111111111111111111111111111111111111111111111100000 0000111111111111111111111111111111111111111111111111111111110000 0001111111111111111111111111111111111111111111111111111111111000 0011111111111111111111111111111111111111111111111111111111111100 0111111111111111000000011111111111111111100000001111111111111110 0111111111110000000000000001111111111000000000000000111111111110 1111111111000000001111000000001111000000001111000000001111111111 1111111110000011111111111100000110000011111111111100000111111111 1111111100000111111111111111000000001111111001111110000011111111 1111111100001111100000011111100000011111100000011111000011111111 1111111100001111100000011111100000011111100000011111000011111111 1111111100000111111111111111000000001111111001111110000011111111 1111111110000011111111111100000110000011111111111100000111111111 1111111111000000001111000000001111000000001111100000001111111111 0111111111110000000000000000111111110000000000000000111111111110 0111111111111111000000001111111111111111000000001111111111111110 0011111111111111111111111111111111111111111111111111111111111100 0001111111111111111111111111111111111111111111111111111111111000 0000111111111111111111111111111111111111111111111111111111110000 0000011111111111111111111111111111111111111111111111111111100000 0000000111111111111111111111111111111111111111111111111110000000 0000000011111111111111111111111111111111111111111111111100000000 0000000000011111111111111111111111111111111111111111100000000000 0000000000000111111111111111111111111111111111111110000000000000 0000000000000000111111111111111111111111111111110000000000000000 0000000000000000000001111111111111111111111000000000000000000000

Teraz powinniśmy podzielić każdy wiersz przez 8, reprezentujący bajt i zapisać je w tablicy, jak poniżej:

static const unsigned char PROGMEM arduino_logo ={

B00000000, B00000000, B00000111, B11111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B11111111, B11111110, B00000000, B00000000, … // kontynuuj do końca rysunku };

Następnie możemy narysować go na wyświetlaczu, wywołując funkcję drawBitmap.

display.drawBitmap(32, 16, arduino_logo, 64, 32, BIAŁY);

Krok 11: Rozwiązywanie problemów

To był długi samouczek, więc jest bardzo prawdopodobne, że coś pójdzie nie tak. Oto lista niektórych typowych błędów, które możesz napotkać podczas konfigurowania modułu wyświetlacza OLED do swojego projektu (część z nich zdarzyła mi się podczas przygotowywania tego samouczka).

W ogóle nic nie jest wyświetlane

Może się to zdarzyć z wielu powodów, dlatego proponuję sprawdzić poniższą listę w kolejności, która może wystąpić w Twoim projekcie:

Adres I2C prawdopodobnie jest błędny

Upewnij się, że ustawiłeś adres, który otrzymałeś w kodzie i2c-scanner w funkcji display.begin() podczas konfigurowania obiektu wyświetlanego.

SCL i SDA są połączone nieprawidłowo

To mi się właściwie przydarzyło. Jeśli używasz Arduino Uno, musisz ponownie sprawdzić połączenia, aby upewnić się, że są połączone tak samo jak moje. Jeśli używasz innej edycji Arduino (np. Mega, Leonardo itp.), musisz wiedzieć, że mogą mieć ustawione I2C na inne piny. Możesz to sprawdzić w dokumentacji biblioteki Wire.

Rysujesz coś poza widocznym obszarem

To jest problem z oprogramowaniem. Bardzo często zdarza się, że podczas korzystania z funkcji rysowania błędnie oblicza się niektóre współrzędne, przez co rysunek może zostać zdeformowany lub w najgorszym przypadku może być całkowicie poza sceną. Przejrzyj swoje obliczenia i spróbuj rysować krok po kroku, aby zobaczyć, co się dzieje.

Tekst w ogóle się nie wyświetla

Zapomniałeś ustawić kolor tekstu lub ustawiłeś złą wartość

Musisz wywołać setTextColor przed rysowaniem tekstów. W przeciwnym razie nie masz żadnych błędów, ale nic nie zobaczysz na wyświetlaczu. Możesz także ustawić kolor tekstu taki sam jak kolor tła.

Używasz bardzo dużej czcionki

Jeśli ustawisz rozmiar tekstu na bardzo dużą wartość, może się zdarzyć, że znaki całkowicie znikną z widocznego obszaru.

Wystąpił błąd kompilacji dotyczący rozmiaru wyświetlacza

Zdarzyło się to również mnie i myślę, że tak się stanie dla większości z was. Dzieje się tak z powodu wartości stałych rozmiaru wyświetlania, które są zdefiniowane w pliku nagłówkowym Adafruit_SSD1306.h, który umieszczamy na górze naszego skryptu. Ten plik znajduje się w {folderze-projektu}\libraries\Adafruit_SSD1306\Adafruit_SSD1306.h. Jeśli otworzysz ten plik, zauważysz, że znajduje się sekcja komentarzy, jak poniżej, w której opisuje, że musisz odkomentować tylko stałą reprezentującą rozmiar modułu wyświetlacza OLED. W przypadku modułów wyświetlacza 128x64 należy odkomentować linię #define SSD1306_128_64.

/*=====================================================================

Wyświetlacze SSD1306 ------------------------------------------------ ---------------------- Sterownik jest używany w wielu wyświetlaczach (128x64, 128x32 itd.). Wybierz odpowiedni wyświetlacz poniżej, aby utworzyć bufor ramki o odpowiedniej wielkości itp. SSD1306_128_64 Wyświetlacz 128x64 pikseli SSD1306_128_32 Wyświetlacz 128x32 pikseli SSD1306_96_16 ---------------------------- --------------------------------------------*/ #define SSD1306_128_64 / / #define SSD1306_128_32 // #define SSD1306_96_16 /*============================================== =========================*/

Krok 12: Co dalej?

Wyświetlacz OLED jako moduł wyjściowy może być świetną okazją do zapewnienia profesjonalnie wyglądającego interfejsu do Twoich hobbystycznych projektów. Możesz spróbować następujących pomysłów jako punktu wyjścia, aby wyświetlić na nim istotne dane lub pomóc użytkownikowi zorientować się, co się dzieje lub czy musi coś zrobić. Dla użytkownika znacznie jaśniejsze byłoby odczytanie komunikatu na wyświetlaczu, niż interpretowanie stanu projektu/urządzenia za pomocą niektórych diod LED.

To, co możesz zrobić jako punkt wyjścia, może być:

• Odczytaj wartość czujnika temperatury i wyświetl ją na module OLED. Możesz dodać do niego czujnik ciśnienia lub wilgotności i stworzyć w pełni funkcjonalny projekt stacji pogodowej.
• Spróbuj narysować coś na module wyświetlacza, używając modułu joysticka jako urządzenia wejściowego.
• Spróbuj narysować animację na wyświetlaczu poprzez sekwencję wywołań funkcji rysowania/opóźniania lub przerwania Arduino
• Wyświetlaj swoje niestandardowe logo podczas uruchamiania systemu (zamiast logo Adafruit)

Nie zapomnij powiedzieć mi w komentarzach, co byś zrobił (lub już zrobiłeś) używając modułu wyświetlacza OLED.