Distracție cu ecran OLED și Arduino: 12 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:41

Sunt destul de sigur că ați auzit cu siguranță despre tehnologia de afișare OLED. Este relativ nou și oferă o calitate mai bună decât tehnologia LCD veche. În acest tutorial vrem să trecem în revistă pașii necesari pentru a afișa date pe unul dintre cele mai comune module de afișare OLED cu o singură culoare disponibile pe piață. Voi încerca să explic funcționalitățile oferite de biblioteca Adafruit corespunzătoare pentru a afișa date pe acest modul.

Pasul 1: Ce module OLED vom folosi?

Modulele OLED sunt disponibile într-o mare varietate de dimensiuni și caracteristici. Cel pe care îl vom folosi în acest tutorial este un modul OLED monocolor 128x64. Acest tip de modul este disponibil în următoarele dimensiuni (Pentru a vedea pe imagini):

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

Deoarece toate aceste module acceptă protocolul I2C ca mijloc de comunicare, codul și cablarea tuturor sunt exact aceleași. Singura diferență este că trebuie să luați în considerare dimensiunea afișajului de pe codul dvs., astfel încât conținutul pe care urmează să îl afișați să se potrivească corect pe acesta.

Pasul 2: I2C pe scurt

Circuitul inter-integrat (IIC) care se numește în mod normal I2C (I pătrat C) dezvoltat de Philips în anii 80 ca o magistrală de schimb de date utilizată pentru a transfera date între unitatea centrală de procesare (CPU) sau unitatea de microcontroler (MCU) a unui dispozitiv și cipuri periferice. Practic a fost vizat pentru aplicații TV. Datorită simplității sale, a devenit atât de popular încât, după o vreme, a devenit unul dintre principalele mecanisme de transfer de date pentru procesoare și MCU-uri și dispozitive periferice care nu fac parte din aceeași placă PCB și sunt conectate la aceasta prin cablu (de exemplu, senzori, module de afișare etc.).

I2C constă dintr-o magistrală de comunicație formată din două fire care acceptă transferul bidirecțional de date între un master și mai multe dispozitive slave. De obicei, nodul master este responsabil de controlul magistralei - ceea ce se face de fapt prin generarea unui semnal de sincronizare pe linia de ceas serial (SCL). Este un semnal care ar fi trimis continuu de către master în timpul transferului, iar toate celelalte noduri conectate la magistrală îl vor folosi pentru a sincroniza comunicarea lor și pentru a detecta viteza autobuzului. Datele sunt transferate între master și slave printr-o linie de date seriale (SDA). Viteza de transmisie poate fi de până la 3,4 Mbps. Toate dispozitivele care doresc să transfere date prin I2C ar trebui să aibă o adresă unică și pot funcționa ca emițător sau receptor în funcție de funcția dispozitivului. De exemplu, un modul de afișare OLED este un receptor care acceptă unele date și le afișează, în timp ce un senzor de temperatură este un transceiver care trimite temperatura captată prin magistrala I2C. În mod normal, un dispozitiv master este dispozitivul care inițiază un transfer de date pe autobuz și generează semnalele de ceas pentru a permite transferul. În timpul acelui transfer, orice dispozitiv adresat de acest master este considerat un sclav și citește aceste date.

Atunci când un nod dorește să trimită unele date, primul octet al datelor ar trebui să fie adresa receptorului și apoi datele reale vin ulterior. Aceasta înseamnă că, pentru a trimite date către un dispozitiv de ieșire folosind I2C (de exemplu, modulul de afișare OLED I2C), ar trebui să găsim mai întâi adresa I2C a acestuia și asta vom face mai întâi la următorii pași.

Dacă sunteți interesat să aflați mai multe despre detalii și teorii despre autobuzul I2C, puteți utiliza următoarele referințe:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Pasul 3: Module și componente necesare

Aici puteți găsi lista componentelor de care ar trebui să completați acest tutorial:

Link-uri eBay:

• 1 x Arduino Uno:
• 1 x modul OLED 128x64:
• 4 x cablu Dupont:
• 1 x Mini placă fără sudură:

Link-uri Amazon.com:

• 1 x Arduino Uno:
• 1 x modul OLED 128x64:
• 4 x cablu Dupont:
• 1 x Mini panou fără sudură:

Pasul 4: Cablarea modulului de afișare OLED la Arduino

O notă importantă despre dispozitivele compatibile cu I2C este că modul în care ar trebui să le conectați la Arduino sunt la fel. Acest lucru se datorează faptului că Arduino își execută comunicarea I2C numai pe pini specifici. În acest tutorial folosesc Arduino Uno. Arduino Uno folosește pinul A5 ca SCK și A4 ca SDA. Deci, putem conecta modulul de afișare OLED la Arduino Uno așa cum se arată în vizualizarea schematică. După cum ați putea observa în imaginea pe care am făcut-o de pe modulul meu de afișare OLED, conectorul pentru VCC și GND sunt diferite de vizualizarea schematică. Nu uitați să verificați etichetele știfturilor de pe module pentru a vă asigura că le conectați într-un mod corect.

Avem nevoie doar de 4 pini care ar trebui conectați ca mai jos:

Arduino VCC -> OLED Module VCC

Arduino GND -> Modul OLED GND

Arduino 4 -> Modul OLED SDA

Arduino 5 -> OLED Module SCK

Pasul 5: Găsirea adresei modulului de afișare

Ca prim pas pentru conectarea la un dispozitiv activat I2C, trebuie să aveți adresa modulului. Pentru a face acest lucru, după ce ați conectat modulul la Arduino, ar trebui să încărcați codul atașat pe Arduino. Acest cod încorporează biblioteca Wire, care este o bibliotecă inclusă cu Arduino IDE care gestionează comunicarea I2C. Încearcă să scaneze dispozitivele I2C conectate și le trimite adresa prin port serial către computer. Deci, puteți accesa ieșirea acestuia prin instrumentul Serial Monitor în Arduino IDE. Versiunea originală este disponibilă la Arduino Playground). De asemenea, îl puteți vizualiza într-un mod mai lizibil în editorul meu online Arduino. Nu vă așteptați să fie afișat nimic pe ecran în timp ce acest cod rulează.

După cum puteți vedea în imagine, modulul meu este legat de adresa 0x3C. În mod normal, toate dispozitivele dintr-o anumită linie de produse (de exemplu, toate modulele OLED de 128x64) au aceeași adresă.

Adresele dispozitivelor I2C sunt limitate de la 1 la 126. Acest cod încearcă pur și simplu să se conecteze la fiecare dispozitiv în ordine (fără a transmite date) și apoi verifică dacă a existat o eroare raportată de biblioteca subiacentă la conectarea la adresa furnizată. Dacă nu există nicio eroare, atunci imprimă adresa ca modul disponibil pentru conectare. De asemenea, trebuie remarcat faptul că primele 15 adrese sunt rezervate, deci sare peste ele și tipărește doar cele de deasupra acestui interval. Amintiți-vă că adresa acestor module I2C sunt codificate pe dispozitiv și nu poate fi modificată. Așadar, ar fi o idee bună să o scrieți undeva sau să puneți o etichetă pe modul atunci când o veți pune din nou pe raftul laboratorului, astfel încât data viitoare, să nu rulați codul scanerului. Cu toate acestea, nu este o procedură complicată;)

Pasul 6: Instalarea bibliotecilor necesare pentru afișarea datelor pe modulul OLED

Biblioteca Wire poate gestiona comunicarea la nivel scăzut cu dispozitivele I2C. Când doriți să vă conectați la un anumit dispozitiv pentru a citi / scrie date de la / către acesta, în mod normal, veți utiliza o bibliotecă furnizată de compania care a construit inițial acel modul. Această bibliotecă gestionează toate detaliile de comunicare I2C cu modulul dat și ne permite să ne concentrăm mai mult pe afacerea noastră care, în acest caz, afișează datele în modul dorit.

Adafruit, compania care produce versiunea originală a acestor module de afișare, oferă o bibliotecă numită Adafruit SSD1306 pentru a afișa date pe aceste afișaje monocrome. Deci, înainte de a începe codarea, trebuie să instalăm această bibliotecă prin Library Manager (accesibil prin Sketch> Include Library> Manage Libraries … menu) în Arduino IDE. Există, de asemenea, o altă bibliotecă numită Adafruit GFX Library, care gestionează mai multe lucruri grafice de nivel scăzut și este utilizată intern de Adafruit SSD1306. Trebuie să aveți ambele instalate pe IDE-ul dvs. Arduino, așa cum puteți vedea pe imagini.

Pasul 7: Inițializarea modulului de afișare

Modulul desenat pe afișaj este împachetat într-o clasă numită Adafruit_SSD1306. Definiția acestei clase se află pe biblioteca Adafruit, deci trebuie mai întâi să includem acea bibliotecă. Apoi trebuie mai întâi să instanțiem o instanță din această clasă. Constructorul acestei clase ia numărul de port la care se poate reseta afișajul, care este pinul 4 (conectat la SCK). Această parte a codului ar trebui să fie localizată la începutul fișierului (în afara funcțiilor setup () și loop ()).

#include

Afișaj Adafruit_SSD1306 (4);

Acum, în interiorul funcției setup () ar trebui să apelăm funcția de începere a obiectului de afișare prin trecerea adresei noastre I2C ca mai jos (SSD1306_SWITCHCAPVCC este o valoare constantă care specifică tipul sursei de alimentare în bibliotecă):

configurare nulă () {

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.display (); } bucla void () {} // bucla poate fi goală deocamdată

Acum obiectul de afișare este gata și îi putem apela funcțiile (de exemplu, display.write (), display.drawLine etc.). Nota importantă este că ori de câte ori atragem ceva apelând la obiectul nostru de afișare, trebuie să apelăm funcția display.display () pentru a face desenul real să se întâmple la nivel hardware. Acest lucru se datorează în principal faptului că funcțiile de desen pe care le numim, doar actualizează reprezentarea „în memorie” a afișajului din motive de performanță. De fapt, ascunde modificările din memorie. Deci, ar trebui să ne amintim întotdeauna să apelăm funcția display () când am terminat de desenat ceva pe ecran.

display.write (…); // continuă actualizarea în memorie

display.drawLine (…); // continuă actualizarea în memorie. display.display (); // curăță toate modificările aduse hardware-ului afișajului

Dacă încercați să încărcați codul în acest pas, veți observa că va fi afișată sigla Adafruit Industries. S-ar putea să vă întrebați cine i-a cerut să deseneze asta! De fapt, asta face biblioteca Adafruit. Inițializează memoria modulului (reprezentarea în memorie a hardware-ului afișajului) cu sigla acestei companii. Dacă nu doriți să vedeți acest lucru în timpul inițializării, puteți încerca să apelați funcția display.clearDisplay () chiar înainte de a apela display.display () în funcția de configurare. Această funcție, așa cum sugerează și numele său, șterge complet ecranul.

#include

Afișaj Adafruit_SSD1306 (4); setare nulă () {display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.display (); } bucla nulă () {}

Pe baza documentației bibliotecii Adafruit_SSD1306, puteți utiliza diferite funcții furnizate de această clasă pentru a desena pe ecran sau pentru a manipula direct pixelii de pe aceasta. În secțiunile următoare vom încerca să prezentăm un exemplu pentru fiecare dintre ele, astfel încât să aveți o idee despre modul în care funcționează. Majoritatea acestor exemple vor afișa doar un conținut static simplu, astfel încât să le putem pune doar în funcția noastră setup () (după codul de inițializare). Procedând astfel, ar fi rulat o singură dată și rămâne acolo.

Pasul 8: Afișați un text simplu

Pentru a afișa un text, putem utiliza funcția simplă display.println () a bibliotecii. Acceptă textul ca un șir și încearcă să-l afișeze. Este important să știm că trebuie să spunem bibliotecii unde vom afișa textul pe ecran. Fiecare pixel de pe afișaj are o coordonată specificată cu X și Y. X crește de la stânga la dreapta și Y crește de sus în jos. Colțul din stânga sus al ecranului este (X = 0, Y = 0), iar colțul din dreapta jos este (X = 127, Y = 63). Am notat coordonatele colțurilor de pe prima imagine. Putem utiliza funcția display.setCursor () pentru a specifica unde vom afișa textul pe ecran.

O altă proprietate a textului este culoarea sa. Putem specifica culoarea folosind display.setTextColor () așa cum este afișat în exemplul următor.

display.clearDisplay ();

display.setTextColor (ALB); display.setCursor (35, 30); display.println ("Hello World!"); display.display ();

De asemenea, putem utiliza funcția display.write () pentru a afișa un singur caracter. Acceptă un cod de caracter ca tip uint8_t și afișează caracterul corespunzător codului respectiv pe șir. De exemplu, dacă dorim să afișăm același șir folosind această funcție, putem folosi următorul fragment:

display.clearDisplay ();

display.setTextColor (ALB); display.setCursor (35, 30); display.write (72); display.write (101); display.write (108); display.write (108); display.write (111); display.write (32); display.write (87); display.write (111); display.write (114); display.write (108); display.write (100); display.write (33); display.display ();

De asemenea, este posibil să desenați texte în culoare neagră cu un fundal alb. Pentru a face acest lucru, trebuie să apelați funcția display.setTextColor după cum urmează:

display.clearDisplay ();

// Setează culoarea pe negru cu un afișaj de fundal alb.setTextColor (NEGRU, ALB); display.setCursor (25, 30); display.println ("Text inversat!"); display.display ();

De asemenea, aveți opțiunea de a seta dimensiunea textului utilizând funcția display.setTextSize (). Acceptă un număr întreg ca dimensiune. Cu cât numărul este mai mare, cu atât textul ar fi mai mare. Cea mai mică dimensiune este 1, care este dimensiunea implicită a textelor. Următorul cod încearcă să scrie litera „A” în 6 dimensiuni diferite:

display.clearDisplay ();

display.setTextColor (ALB); 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 ();

Pasul 9: Desenarea formelor de bază

Desenarea formelor de bază precum dreptunghi, cerc, triunghi, linie sau punct sunt foarte ușoare și există o funcție dedicată pentru fiecare.

Linia de desen

Pentru a desena o linie puteți apela display.drawLine (startX, startY, endX, endY, color). De exemplu, următorul cod trasează o linie diagonală pe ecran, astfel încât să modeleze un X mare:

display.clearDisplay ();

display.drawLine (0, 0, display.width () - 1, display.height () - 1, WHITE); display.drawLine (display.width () - 1, 0, 0, display.height () - 1, WHITE); display.display ();

Puteți accesa lățimea și înălțimea afișajului utilizând funcțiile display.width () și display.height (). Procedând astfel, codul dvs. ar fi independent de dimensiunea ecranului.

Desen dreptunghi

Funcția de a desena un dreptunghi este display.drawRect (upperLeftX, upperLeftY, lățime, înălțime, culoare). Iată codul care desenează trei dreptunghiuri pe unele locuri aleatorii:

display.clearDisplay ();

display.drawRect (100, 10, 20, 20, ALB); display.fillRect (10, 10, 45, 15, ALB); display.drawRoundRect (60, 20, 35, 35, 8, WHITE); display.display ();

Apelând display.fillRect (upperLeftX, upperLeftY, width, height, WHITE) puteți desena un dreptunghi umplut cu culoarea specificată. De asemenea, a treia funcție din acest exemplu este display.drawRoundRect (upperLeftX, upperLeftY, width, height, cornerRadius, color) care, după cum puteți vedea în imagine, este utilizată pentru a desena un dreptunghi cu colțuri rotunde. Acceptă un parametru suplimentar înainte de culoare care este un număr întreg care indică raza colțului. Cu cât valoarea este mai mare, cu atât colțul este mai rotund. De asemenea, are o funcție de umplere corespunzătoare numită display.drawFillRoundRect pe care cred că o puteți ghici ce face.

Cerc de desen

Funcția este display.drawCircle (centerX, centerY, raza, culoare). Iată un exemplu care desenează o formă asemănătoare zâmbetului:

display.drawCircle (60, 30, 30, ALB);

display.fillCircle (50, 20, 5, ALB); display.fillCircle (70, 20, 5, ALB);

La fel ca dreptunghiurile, puteți utiliza funcția display.fillCircle pentru a desena un cerc umplut cu culoarea dată.

Desen triunghi

Ahh, din nou o funcție numită display.drawTriangle (poin1X, point1Y, point2X, point2Y, point3X, point3Y, color) și display.fillTriangle corespunzător care desenează un triunghi umplut.

display.drawTriangle (24, 1, 3, 55, 45, 55, WHITE);

display.fillTriangle (104, 62, 125, 9, 83, 9, WHITE);

Desenați un punct

De asemenea, puteți colora un anumit punct (care se numește pixel) pe ecran prin funcția display.drawPixel (pixelX, pixelY, color).

display.drawPixel (20, 35, ALB);

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

Pasul 10: Desenarea imaginii

Desenarea unei imagini este diferită și cam complicată. Deoarece modulul de afișare este monocolor, trebuie mai întâi să ne convertim imaginea într-un format numit bitmap mono culoare (numit și alb-negru). Într-un astfel de format, fiecare pixel al imaginii este prezentat fie cu 0, fie cu 1. 1 reprezintă existența culorii și 0 înseamnă un spațiu gol. Puteți vedea un exemplu de sigla Arduino în acest format deasupra acestei secțiuni. Funcția de a desena o imagine bitmap este display.drawBitmap (topLeftX, topLeftY, imageData, lățime, înălțime, culoare). Parametrul imageData este o matrice de numere în octeți. Fiecare octet are 8 biți, deci fiecare octet conține datele a 8 pixeli ai imaginii. Prin specificarea lățimii și înălțimii imaginii, funcția drawBitmap va ști din ce bit începe următorul rând de pixeli.

Soluția pe care am ales-o pentru a-mi converti imaginea în acest format a fost să folosesc mai întâi unul dintre „convertoarele de imagini în ASCII” online (de exemplu, https://my.asciiart.club) pentru a-mi converti imaginea într-un set de caractere ASCII și apoi înlocui caracterele folosite pentru spațiul gol de 0 și altele de 1. Asta vedeți mai jos. Vă puteți gândi la fiecare 0 și 1 ca la un pixel pe ecran. Deci, dimensiunea imaginii nu trebuie să depășească dimensiunea afișajului nostru, care este de 128x64.

Notă: Utilizarea acestei tehnici ASCII nu este o abordare recomandată, deoarece datorită raportului de aspect al caracterelor, imaginea dvs. va fi deformată (caracterele nu sunt pătrate). Am încercat această tehnică doar pentru că facilitează conversia imaginii în formatul dorit. În caz contrar, ar fi posibil să se obțină cel mai bun rezultat prin intermediul unor programe sau utilizând unele aplicații utilitare care sunt complet în afara sferei acestui text.

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

Acum ar trebui să împărțim fiecare linie la 8, reprezentând un octet și să le stocăm într-o matrice după cum urmează:

static const unsigned char PROGMEM arduino_logo = {

B00000000, B00000000, B00000111, B11111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B11111111, B11111110, B00000000, B00000000, // până la sfârșitul anului;

Apoi îl putem desena pe ecran apelând funcția drawBitmap.

display.drawBitmap (32, 16, arduino_logo, 64, 32, WHITE);

Pasul 11: Depanare

Acesta a fost un tutorial lung și, prin urmare, este foarte probabil că ceva nu merge bine. Iată lista cu câteva erori frecvente pe care le puteți întâlni în timp ce configurați modulul de afișare OLED pentru proiectul dvs. (unele dintre ele s-au întâmplat pentru mine în timpul pregătirii acestui tutorial).

Nu se afișează nimic

Acest lucru s-ar putea întâmpla din mai multe motive, așa că vă sugerez să verificați următoarea listă care este în ordinea care poate apărea în proiectul dvs.:

Adresa I2C este probabil greșită

Asigurați-vă că ați setat adresa obținută în codul scanerului i2c în funcția display.begin () atunci când configurați obiectul de afișare.

SCL și SDA sunt conectate într-un mod greșit

Acest lucru s-a întâmplat de fapt pentru mine. Dacă utilizați Arduino Uno, atunci trebuie să vă verificați din nou conexiunile pentru a vă asigura că sunt conectate la fel ca a mea. Dacă utilizați o altă ediție Arduino (de exemplu, Mega, Leonardo, etc.), trebuie să știți că este posibil ca I2C să fie setat pe alți pini. O puteți verifica la documentația bibliotecii Wire.

Trageți ceva din zona vizibilă

Aceasta este o problemă de software. Este foarte frecvent atunci când utilizați funcții de desen pentru a calcula greșit unele coordonate, astfel încât desenul dvs. s-ar deforma sau, în cel mai rău scenariu, ar putea fi complet în afara scenei. Examinați calculele și încercați să faceți un desen pas cu pas pentru a vedea ce se întâmplă.

Textul nu este deloc afișat

Ați uitat să setați culoarea textului sau ați setat-o la o valoare greșită

Trebuie să apelați setTextColor înainte de a desena texte. În caz contrar, nu aveți erori, dar nu veți vedea nimic afișat. De asemenea, este posibil să fi setat culoarea textului la fel ca și culoarea de fundal.

Folosiți un font foarte mare

Dacă setați dimensiunea textului la o valoare foarte mare, ar putea fi posibil ca caracterele să iasă complet din zona vizibilă.

Există o eroare de compilare despre dimensiunea afișajului

Acest lucru s-a întâmplat și pentru mine și cred că s-ar întâmpla pentru majoritatea dintre voi. Datorită valorilor constante ale dimensiunii afișării, care sunt definite în fișierul de antet Adafruit_SSD1306.h pe care le includem în partea de sus a scriptului nostru. Acest fișier se află la {folderul-proiectului} libraries / Adafruit_SSD1306 / Adafruit_SSD1306.h. Dacă deschideți acest fișier, veți observa că există o secțiune de comentarii ca mai jos, în care descrie că trebuie să decomentați doar constanta care reprezintă dimensiunea modulului dvs. de afișare OLED. Pentru un modul de afișare 128x64, linia #define SSD1306_128_64 ar trebui să fie necomentată.

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

Afișează SSD1306 ------------------------------------------------ ---------------------- Driverul este utilizat în mai multe afișaje (128x64, 128x32 etc.). Selectați afișajul corespunzător de mai jos pentru a crea un framebuffer de dimensiuni adecvate etc. SSD1306_128_64 Afișaj 128x64 pixeli SSD1306_128_32 Afișaj 128x32 pixeli SSD1306_96_16 -------------------------- -------------------------------------------- * / #define SSD1306_128_64 / / #define SSD1306_128_32 // #define SSD1306_96_16 / * ========================================= =============================== * /

Pasul 12: Ce să faci în continuare?

Afișajul OLED ca modul de ieșire vă poate oferi o mare oportunitate de a oferi o interfață cu aspect profesional pentru proiectele dvs. hobby. Puteți încerca să urmăriți ideile ca punct de plecare pentru a afișa date semnificative pe ea sau pentru a ajuta utilizatorul să știe ce se întâmplă sau dacă el / ea trebuia să facă ceva. Ar fi mult mai clar pentru un utilizator să citească un mesaj pe un afișaj decât să interpreteze starea unui proiect / dispozitiv prin intermediul unor LED-uri.

Ce puteți face ca punct de plecare ar putea fi:

• Citiți valoarea senzorului de temperatură și afișați-o pe modulul OLED. Puteți adăuga senzor de presiune sau umiditate la acesta și puteți crea un proiect de stație meteo complet funcțional.
• Încercați să desenați ceva pe modulul de afișare utilizând un modul joystick ca dispozitiv de intrare.
• Încercați să desenați o animație pe ecran printr-o secvență de apeluri de funcții de desen / întârziere sau întrerupere Arduino
• Afișați sigla personalizată la pornirea sistemului (în loc de sigla Adafruit)

Nu uitați să-mi spuneți comentarii, ce ați face (sau ați făcut deja) folosind modulul de afișare OLED.