Cum conectezi un ecran OLED I2C la Arduino: schemă, cod și depanare
Construiește un proiect cu Arduino și un ecran OLED I2C: identifică pinii, verifică adresa, instalează bibliotecile SSD1306 și afișează date cu un program complet.
Un ecran OLED mic poate transforma un montaj Arduino într-un dispozitiv care afișează măsurători, stări de funcționare, mesaje și meniuri fără să fie nevoie de un calculator conectat permanent. Modulele OLED cu interfață I2C sunt populare în proiectele educaționale deoarece folosesc doar câteva fire, iar biblioteca potrivită oferă funcții simple pentru text și forme grafice.
În acest ghid conectăm un modul OLED monocrom de tip 128 × 64, bazat pe controlerul SSD1306, la o placă Arduino UNO. Verificăm adresa I2C, instalăm bibliotecile necesare, încărcăm un program complet și rezolvăm problemele întâlnite frecvent. Înainte de montaj, verifică marcajele și fișa tehnică a modulului tău: există ecrane asemănătoare care folosesc alt controler, altă rezoluție sau alte cerințe de alimentare.
Ce este un ecran OLED I2C și cum funcționează
OLED înseamnă Organic Light-Emitting Diode. Fiecare pixel produce lumină, astfel că un ecran OLED nu are nevoie de o iluminare de fundal separată, așa cum se întâmplă la multe module LCD. În proiectele cu Arduino întâlnești frecvent module monocrome de 0,96 sau 1,3 inch, cu rezoluții precum 128 × 64 ori 128 × 32 pixeli.
Interfața I2C permite plăcii să comunice cu ecranul folosind două linii: SDA pentru date și SCL pentru ceas. Pe lângă acestea, modulul are nevoie de alimentare și masă. Magistrala poate fi împărțită cu alte dispozitive I2C, dacă acestea folosesc adrese diferite și respectă cerințele electrice ale magistralei.
SSD1306 este controlerul întâlnit pe multe dintre aceste module. Nu presupune însă că orice ecran OLED mic folosește SSD1306: unele modele folosesc SH1106 sau alt controler, iar biblioteca trebuie să corespundă componentei reale. Verifică descrierea produsului, inscripțiile de pe placă și documentația furnizorului înainte să alegi biblioteca.
Componente necesare pentru proiect
Pentru montajul demonstrativ ai nevoie de:
- O placă Arduino UNO R3 sau o placă compatibilă cu biblioteca și interfața I2C folosite.
- Un modul OLED I2C monocrom, preferabil 128 × 64, cu controler SSD1306 identificat.
- Patru fire jumper potrivite conectorilor modulului.
- Un cablu USB pentru alimentarea și programarea plăcii.
- Un calculator cu Arduino IDE instalat.
Breadboard-ul este opțional, dar ajută dacă modulul nu are pini deja montați. Nu ai nevoie de rezistențe externe în toate cazurile: unele plăcuțe OLED includ rezistențe pull-up pentru I2C, însă acest lucru depinde de model.
Verifică rezoluția, controlerul și tensiunea modulului
Înainte să conectezi firele, identifică trei detalii. Primul este controlerul: codul din acest articol folosește biblioteca Adafruit SSD1306 și este destinat unui modul compatibil cu SSD1306. Al doilea este rezoluția: în exemplu folosim 128 × 64 pixeli. Al treilea este alimentarea acceptată de placa OLED.
Unele module au regulator și circuite de adaptare care permit alimentarea de la 5 V, în timp ce altele sunt proiectate pentru 3,3 V. Nu conecta automat pinul VCC la 5 V doar pentru că folosești un Arduino UNO. Citește specificațiile modulului și respectă tensiunea indicată de producător.
Verifică separat și nivelurile logice ale liniilor SDA și SCL. Dacă modulul are rezistențele pull-up conectate la 3,3 V, păstrează magistrala la nivelul compatibil cu toate dispozitivele. Dacă placa OLED este strict de 3,3 V, iar placa Arduino folosește semnale I2C de 5 V, utilizează un convertor bidirecțional de nivel logic potrivit. Faptul că un modul pornește la 5 V nu înseamnă automat că intrările sale de date tolerează 5 V.
Schema de conectare OLED la Arduino UNO R3
Pe Arduino UNO R3, liniile I2C sunt A4 pentru SDA și A5 pentru SCL. Placa are și pini marcați SDA și SCL lângă AREF; aceștia corespund aceleiași magistrale. Pentru montajul de bază, folosește următoarele conexiuni, după ce ai confirmat tensiunea acceptată de modul:
| Pin OLED | Arduino UNO R3 | Rol |
|---|---|---|
| GND | GND | Masă comună |
| VCC | 5V sau 3.3V, conform fișei modulului | Alimentare |
| SDA | A4 / SDA | Date I2C |
| SCL | A5 / SCL | Ceas I2C |
Deconectează placa de la USB înainte să schimbi firele. Leagă GND la GND, apoi verifică atent VCC, SDA și SCL. Nu inversa liniile de date și ceas. Dacă folosești alt model Arduino, consultă pinout-ul acelei plăci: poziția SDA și SCL poate fi diferită de cea de pe UNO R3.
Dacă ai deja un proiect cu un senzor conectat la I2C, nu trebuie neapărat să rezervi o pereche separată de pini pentru ecran. Dispozitivele pot împărți magistrala, cu condiția să nu aibă aceeași adresă I2C și să fie respectate limitele electrice și de cablare.
Verifică adresa I2C cu un scanner
Un motiv frecvent pentru care ecranul nu afișează nimic este folosirea unei adrese I2C diferite de cea configurată în program. Valorile 0x3C și 0x3D sunt întâlnite la multe module SSD1306, dar nu trebuie presupusă una dintre ele fără verificare. Un scanner I2C simplu poate identifica dispozitivele care răspund pe magistrală.
În Arduino IDE creează un sketch nou și încarcă programul de mai jos. El caută adresele I2C uzuale și afișează în Serial Monitor dispozitivele care răspund:
#include <Wire.h>
void setup() {
Wire.begin();
Serial.begin(9600);
while (!Serial) {
; // Așteaptă portul serial pe plăcile care au nevoie
}
Serial.println("Scanare I2C...");
}
void loop() {
byte eroare;
byte adresa;
byte gasite = 0;
for (adresa = 1; adresa < 127; adresa++) {
Wire.beginTransmission(adresa);
eroare = Wire.endTransmission();
if (eroare == 0) {
Serial.print("Dispozitiv gasit la adresa 0x");
if (adresa < 16) {
Serial.print("0");
}
Serial.println(adresa, HEX);
gasite++;
}
}
if (gasite == 0) {
Serial.println("Nu a fost gasit niciun dispozitiv I2C.");
}
delay(3000);
}
Deschide Serial Monitor și selectează 9600 baud. Dacă scannerul găsește o adresă, noteaz-o: o vei introduce în programul pentru OLED. Dacă nu găsește nimic, verifică alimentarea, masa comună, firele SDA/SCL, tensiunea logică și contactele. Un rezultat fără dispozitive nu dovedește singur că ecranul este defect; poate indica și o conexiune greșită sau un modul care nu este alimentat corect.
Instalează bibliotecile Adafruit SSD1306 și GFX
Biblioteca Adafruit SSD1306 gestionează comunicarea cu controlerul ecranului, iar Adafruit GFX oferă funcțiile grafice pentru text, linii, dreptunghiuri, cercuri și alte forme. Pentru exemplul nostru sunt necesare ambele biblioteci.
În Arduino IDE:
- Deschide Library Manager din meniul Sketch sau din pictograma dedicată, în funcție de versiunea IDE.
- Caută Adafruit SSD1306 și instalează biblioteca publicată de Adafruit.
- Caută Adafruit GFX Library și instaleaz-o dacă nu este deja prezentă.
- Acceptă instalarea dependențelor propuse de Library Manager.
- Repornește sau redeschide sketch-ul dacă IDE-ul nu recunoaște imediat bibliotecile.
Nu instala la întâmplare mai multe biblioteci cu nume asemănătoare. Dacă modulul tău folosește SH1106, o bibliotecă pentru SSD1306 poate să nu îl inițializeze corect, chiar dacă ecranul arată aproape identic. Identificarea controlerului trebuie făcută înainte de depanarea codului.
Program complet pentru afișarea textului pe OLED
După ce scannerul a identificat adresa și ai instalat bibliotecile, creează un sketch nou. Exemplul următor este pentru un modul SSD1306 de 128 × 64 pixeli. Înlocuiește valoarea 0x3C cu adresa găsită de scanner dacă modulul tău răspunde la altă adresă.
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
// Înlocuiește adresa cu valoarea găsită de scannerul I2C.
#define SCREEN_ADDRESS 0x3C
Adafruit_SSD1306 display(
SCREEN_WIDTH,
SCREEN_HEIGHT,
&Wire,
OLED_RESET
);
void setup() {
Serial.begin(9600);
if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
Serial.println("Initializarea OLED a esuat.");
while (true) {
delay(10);
}
}
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0, 0);
display.println(F("Scoala IT"));
display.println(F("OLED + Arduino"));
display.drawLine(0, 25, 127, 25, SSD1306_WHITE);
display.setCursor(0, 34);
display.println(F("I2C functioneaza"));
display.println(F("Afisaj 128 x 64"));
display.display();
}
void loop() {
static unsigned long ultimaActualizare = 0;
if (millis() - ultimaActualizare >= 500) {
ultimaActualizare = millis();
display.fillRect(0, 52, 128, 12, SSD1306_BLACK);
display.setCursor(0, 54);
display.print(F("Timp: "));
display.print(millis() / 1000);
display.print(F(" s"));
display.display();
}
}
În constructor am folosit lățimea de 128 pixeli, înălțimea de 64 și obiectul Wire pentru magistrala I2C. Valoarea OLED_RESET -1 indică faptul că exemplul nu folosește un pin separat de reset al ecranului. Dacă modulul tău are o conexiune de reset utilizată în montaj, adaptează definiția și constructorul conform documentației bibliotecii și a plăcii OLED.
Funcția display.begin() inițializează biblioteca și bufferul grafic. Desenarea se face în bufferul din memoria plăcii, iar apelul display.display() transferă imaginea către ecran. De aceea, după ce modifici textul sau formele, trebuie să apelezi din nou display.display() pentru a vedea actualizarea.
Pentru un modul de 128 × 32, schimbă SCREEN_HEIGHT la 32 și adaptează pozițiile textului și ale formelor. Nu folosi automat coordonatele din exemplul de 64 de pixeli înălțime pe un ecran mai mic, deoarece o parte din conținut poate ieși în afara suprafeței vizibile.
Cum verifici că afișajul funcționează corect
După încărcarea programului, ecranul ar trebui să afișeze două rânduri de text, o linie orizontală și un contor care se actualizează periodic. Dacă scannerul a găsit adresa, dar ecranul rămâne gol, verifică mai întâi adresa definită în program, rezoluția și controlerul modulului.
Dacă afișajul este vizibil, dar textul pare tăiat, verifică dimensiunea ecranului și coordonatele folosite în setCursor(). Coordonatele încep de la colțul din stânga sus, unde punctul 0,0 reprezintă originea. La setTextSize(1), biblioteca folosește fontul său de bază; mărirea textului reduce numărul de caractere care încap pe fiecare rând.
Probleme frecvente și metode de depanare
Scannerul I2C nu găsește niciun dispozitiv
Verifică dacă placa OLED primește tensiunea corectă, dacă GND este comun și dacă SDA și SCL sunt conectate la pinii potriviți. Inspectează firele și breadboard-ul, apoi testează din nou. Dacă folosești un convertor de nivel logic, verifică și conexiunile sale pe ambele părți. Un modul alimentat incorect sau o magistrală blocată poate să nu răspundă la scanare.
Scannerul găsește dispozitivul, dar ecranul rămâne negru
Adresa I2C confirmă că un dispozitiv răspunde, dar nu demonstrează automat că biblioteca și controlerul sunt compatibile. Confirmă dacă modulul folosește SSD1306 sau SH1106, apoi verifică rezoluția și valoarea SCREEN_ADDRESS. Unele module au nevoie de o altă bibliotecă sau de o configurare diferită.
Ecranul afișează doar o parte din text
Verifică SCREEN_WIDTH, SCREEN_HEIGHT, dimensiunea fontului și coordonatele de desenare. Un cod scris pentru 128 × 64 nu se potrivește automat unui modul de 128 × 32. Dacă folosești caractere speciale, ține cont că fontul implicit al bibliotecii nu oferă în mod necesar toate caracterele Unicode; pentru diacritice sau simboluri suplimentare poate fi nevoie de un font și de o metodă de randare potrivite.
Afișajul funcționează intermitent sau se resetează
Verifică stabilitatea alimentării, lungimea firelor și calitatea contactelor. Firele I2C foarte lungi sau traseele dezordonate pot afecta comunicarea. Dacă ai mai multe module pe aceeași magistrală, verifică adresele și rezistențele pull-up: prea multe rezistențe în paralel pot modifica comportamentul electric al magistralei. Începe cu fire scurte și un singur dispozitiv conectat, apoi adaugă celelalte componente pe rând.
Sketch-ul nu mai încape în memoria plăcii
Un buffer complet pentru un ecran monocrom de 128 × 64 ocupă 1024 de octeți, fără să includem variabilele și stiva programului. Arduino UNO R3 are 2 KB de SRAM, deci proiectele cu multe texte, imagini bitmap și biblioteci suplimentare pot ajunge repede la limita memoriei. Redu numărul de variabile globale, evită buffer-ele inutile și păstrează imaginile mari în memoria programului, folosind mecanismele potrivite pentru platforma aleasă.
Extinde proiectul cu senzori și butoane
După ce afișajul funcționează, poți transforma montajul într-un mic panou de monitorizare. De exemplu, poți afișa distanța calculată de senzorul ultrasonic HC-SR04, pe care îl prezentăm în ghidul despre măsurarea distanței cu Arduino. În loc să trimiți rezultatul doar în Serial Monitor, îl poți reda pe ecran, cu o etichetă și o unitate de măsură.
O altă extensie este afișarea temperaturii citite de DS18B20. Articolul despre conectarea și citirea senzorului DS18B20 explică partea de măsurare; ecranul OLED poate deveni interfața care prezintă temperatura și starea proiectului. Poți adăuga și un buton pentru schimbarea paginilor, folosind metoda de citire și debounce din ghidul despre INPUT_PULLUP și debounce.
Dacă vrei să afișezi poziția unui mecanism, poți combina ecranul cu un servomotor și să arăți valoarea de comandă sau starea mișcării. În acest caz, urmărește separat alimentarea servomotorului și limitele curentului disponibil pe placa Arduino; nu alimenta un motor direct dintr-un pin GPIO.
Documentație oficială și biblioteci pentru continuarea proiectului
Pentru pinout și caracteristicile plăcii, consultă documentația oficială Arduino UNO R3. Pentru comunicarea I2C, folosește referința Arduino pentru biblioteca Wire. Aceste resurse te ajută să verifici pinii și funcțiile folosite în sketch.
Codul și exemplele bibliotecii sunt disponibile în depozitul oficial Adafruit SSD1306, iar funcțiile grafice sunt documentate în Adafruit GFX Library. Poți compara programul din acest articol cu exemplul Adafruit pentru ecranul SSD1306 de 128 × 64 prin I2C.
De la primul mesaj la un panou de monitorizare
Un ecran OLED I2C este o extensie utilă pentru proiectele Arduino: poate afișa valori de la senzori, starea unor ieșiri, mesaje de diagnostic și informații despre funcționarea montajului. Începe cu identificarea corectă a controlerului, verifică tensiunea și adresa I2C, apoi testează un program simplu înainte să adaugi alte componente.
După ce afișajul funcționează stabil, adaugă câte o funcție pe rând și verifică memoria disponibilă, alimentarea și comunicarea dintre module. Astfel, proiectul poate evolua de la afișarea unui mesaj la o interfață practică pentru un termometru, un senzor de distanță sau un mic sistem de automatizare.
Descoperă mai multe la Scoala IT
Abonează-te ca să primești ultimele articole prin email.