Divertimento con display OLED e Arduino: 12 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

Sono abbastanza sicuro che tu abbia sicuramente sentito parlare della tecnologia di visualizzazione OLED. È relativamente nuovo e offre una qualità migliore rispetto alla vecchia tecnologia LCD. In questo tutorial vogliamo rivedere i passaggi necessari per visualizzare i dati su uno dei più comuni moduli display OLED monocolore disponibili sul mercato. Cercherò di spiegare le funzionalità fornite dalla corrispondente libreria Adafruit per visualizzare i dati su questo modulo.

Passaggio 1: quali moduli OLED utilizzeremo?

I moduli OLED sono disponibili in un'ampia varietà di dimensioni e caratteristiche. Quello che useremo in questo tutorial è un modulo OLED 128x64 monocolore. Questo tipo di modulo è disponibile nelle seguenti dimensioni (nell'ordine che vedete nelle immagini):

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

Poiché tutti questi moduli supportano il protocollo I2C come mezzo di comunicazione, il codice e il cablaggio di tutti loro sono esattamente gli stessi. L'unica differenza è che devi considerare la dimensione del display sul tuo codice in modo che i contenuti che stai per visualizzare si adattino correttamente ad esso.

Passaggio 2: I2C in poche parole

Il circuito inter-integrato (IIC) che viene normalmente chiamato I2C (I al quadrato C) sviluppato da Philips negli anni '80 come bus di scambio dati utilizzato per trasferire dati tra l'unità di elaborazione centrale (CPU) o l'unità a microcontrollore (MCU) di un dispositivo e chip periferici. Era fondamentalmente mirato per l'applicazione TV. Grazie alla sua semplicità, è diventato così popolare che nel tempo è diventato uno dei principali meccanismi di trasferimento dati per CPU e MCU e dispositivi periferici che non sono necessariamente parte della stessa scheda PCB e sono collegati ad essa tramite filo (es. moduli di visualizzazione, ecc.).

I2C è costituito da un bus di comunicazione a due fili che supporta il trasferimento dati bidirezionale tra un master e più dispositivi slave. Tipicamente il nodo master ha il compito di controllare il bus, cosa che in realtà avviene generando un segnale di sincronizzazione sulla linea di clock seriale (SCL). È un segnale che verrebbe inviato continuamente dal master durante il trasferimento e tutti gli altri nodi collegati al bus lo utilizzeranno per sincronizzare la loro comunicazione e rilevare la velocità del bus. I dati vengono trasferiti tra master e slave tramite una linea dati seriale (SDA). La velocità di trasmissione può arrivare fino a 3,4 Mbps. Tutti i dispositivi che desiderano trasferire dati tramite I2C devono avere un indirizzo univoco e possono funzionare come trasmettitore o ricevitore a seconda della funzione del dispositivo. Ad esempio un modulo display OLED è un ricevitore che accetta alcuni dati e li visualizza, mentre un sensore di temperatura è un ricetrasmettitore che invia la temperatura acquisita tramite bus I2C. Normalmente un dispositivo master è il dispositivo che avvia un trasferimento dati sul bus e genera i segnali di clock per consentire il trasferimento. Durante quel trasferimento, qualsiasi dispositivo indirizzato da questo master è considerato uno slave e legge quei dati.

Quando un nodo vuole inviare dei dati, il primo byte dei dati dovrebbe essere l'indirizzo del destinatario e poi i dati effettivi vengono dopo. Ciò significa che per inviare un dato a un dispositivo di output utilizzando I2C (ad es. modulo display OLED I2C) dovremmo prima trovare il suo indirizzo I2C e questo è ciò che faremo per primo nei passaggi successivi.

Se sei interessato a saperne di più sui dettagli e le teorie sul bus I2C, puoi utilizzare i seguenti riferimenti:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Passaggio 3: moduli e componenti richiesti

Qui puoi trovare l'elenco dei componenti necessari per completare questo tutorial:

Link eBay:

• 1 x Arduino Uno:
• 1 x modulo OLED 128x64:
• 4 x cavo Dupont:
• 1 x Mini breadboard senza saldatura:

Link Amazon.com:

• 1 x Arduino Uno:
• 1 x modulo OLED 128x64:
• 4 x cavo Dupont:
• 1 x Mini breadboard senza saldatura:

Passaggio 4: cablaggio del modulo display OLED ad Arduino

Una nota importante sui dispositivi abilitati I2C è che il modo in cui dovresti collegarli ad Arduino è lo stesso. Questo perché Arduino esegue la sua comunicazione I2C solo su pin specifici. In questo tutorial sto usando Arduino Uno. L'Arduino Uno utilizza il pin A5 come SCK e A4 come SDA. Quindi possiamo collegare il modulo display OLED ad Arduino Uno come mostrato nella vista schematica. Come puoi notare nell'immagine che ho preso dal mio modulo display OLED, il connettore per VCC e GND sono diversi dalla vista schematica. Ricordati di controllare le etichette dei pin sui tuoi moduli per assicurarti di collegarli nel modo giusto.

Abbiamo bisogno solo di 4 pin che dovrebbero essere collegati come di seguito:

Arduino VCC -> Modulo OLED VCC

Arduino GND -> GND modulo OLED

Arduino 4 -> Modulo OLED SDA

Arduino 5 -> Modulo OLED SCK

Passaggio 5: trovare l'indirizzo del modulo display

Come primo passo per la connessione a un dispositivo abilitato I2C, è necessario disporre dell'indirizzo del modulo. Per fare ciò, dopo aver collegato il modulo al tuo Arduino, dovresti semplicemente caricare il codice allegato, sul tuo Arduino. Questo codice incorpora la libreria Wire che è una libreria inclusa con Arduino IDE che gestisce la comunicazione I2C. Prova a scansionare i dispositivi I2C collegati e invia il loro indirizzo tramite porta seriale al tuo computer. Quindi puoi accedere al suo output tramite lo strumento Serial Monitor in Arduino IDE. La versione originale è disponibile su Arduino Playground). Inoltre puoi visualizzarlo in un modo più leggibile nel mio editor Arduino online. Non aspettarti che venga visualizzato nulla sullo schermo mentre questo codice è in esecuzione.

Come puoi vedere nell'immagine, il mio modulo è legato all'indirizzo 0x3C. Normalmente tutti i dispositivi di una specifica linea di prodotti (ad esempio tutti i moduli OLED 128x64) hanno lo stesso indirizzo.

Gli indirizzi dei dispositivi I2C sono limitati da 1 a 126. Questo codice cerca semplicemente di connettersi a ciascun dispositivo in ordine (senza trasmettere alcun dato) e quindi controlla se è stato segnalato un errore dalla libreria sottostante durante la connessione all'indirizzo fornito. Se non ci sono errori, stampa l'indirizzo come modulo disponibile per la connessione. Inoltre, va notato che i primi 15 indirizzi sono riservati, quindi li salta e stampa solo quelli al di sopra di questo intervallo. Ricorda che l'indirizzo di questi moduli I2C è hardcoded sul dispositivo e non può essere modificato. Quindi sarebbe una buona idea scriverlo da qualche parte o mettere un'etichetta sul modulo quando lo rimetterai sullo scaffale del laboratorio in modo che la volta successiva non sia necessario eseguire il codice dello scanner. Comunque non è una procedura complicata;)

Passaggio 6: installazione delle librerie necessarie per visualizzare i dati sul modulo OLED

La libreria Wire può gestire comunicazioni di basso livello con dispositivi I2C. Quando si desidera connettersi a un dispositivo specifico per leggere/scrivere dati da/su di esso, normalmente si utilizza una libreria fornita dall'azienda che ha originariamente costruito quel modulo. Questa libreria gestisce tutti i dettagli della comunicazione I2C con un determinato modulo e ci consente di concentrarci maggiormente sulla nostra attività che in questo caso visualizza i dati nel modo desiderato.

Adafruit, l'azienda che produce la versione originale di tali moduli display, fornisce una libreria chiamata Adafruit SSD1306 per visualizzare i dati su questi display monocromatici. Quindi, prima di iniziare a codificare, dobbiamo installare questa libreria tramite Library Manager (accessibile tramite Sketch> Includi libreria> Gestisci librerie … menu) in Arduino IDE. C'è anche un'altra libreria chiamata Adafruit GFX Library che gestisce più cose grafiche di basso livello ed è usata internamente da Adafruit SSD1306. Devi averli entrambi installati sul tuo IDE Arduino come puoi vedere nelle immagini.

Passaggio 7: inizializzazione del modulo display

Il modulo Drawing on display è racchiuso in una classe denominata Adafruit_SSD1306. La definizione di questa classe è sulla libreria Adafruit, quindi dobbiamo prima includere quella libreria. Quindi dobbiamo prima istanziare un'istanza di questa classe. Il costruttore di questa classe prende il numero di porta a cui il display può essere resettato che è il pin 4 (collegato a SCK). Questa parte del codice dovrebbe trovarsi all'inizio del file (fuori dalle funzioni setup() e loop()).

#includere

Adafruit_SSD1306 display(4);

Ora all'interno della funzione setup() dovremmo chiamare la funzione begin dell'oggetto display passando il nostro indirizzo I2C come di seguito (il SSD1306_SWITCHCAPVCC è un valore costante che specifica il tipo di alimentazione alla libreria):

void setup() {

display.begin(SSD1306_SWITCHCAPVCC, 0x3C); display.display(); } void loop() {} // il loop può essere vuoto per ora

Ora l'oggetto display è pronto e possiamo richiamare le sue funzioni (es. display.write(), display.drawLine, ecc.). La nota importante è che ogni volta che disegniamo qualcosa chiamando il nostro oggetto di visualizzazione, dobbiamo chiamare la funzione display.display() per far sì che il disegno effettivo avvenga a livello hardware. Ciò è dovuto principalmente al fatto che le funzioni di disegno che chiamiamo, aggiornano semplicemente la rappresentazione "in memoria" del display per motivi di prestazioni. In realtà memorizza nella cache le modifiche in memoria. Quindi dovremmo sempre ricordarci di chiamare la funzione display() quando abbiamo finito di disegnare qualcosa sullo schermo.

display.write(…); // mantiene l'aggiornamento in memoria

display.drawLine(…); // mantiene l'aggiornamento in memoria. display.display(); // cancella tutte le modifiche all'hardware del display

Se provi a caricare il tuo codice in questo passaggio, noterai che verrà visualizzato il logo di Adafruit Industries. Potresti chiederti chi gli ha chiesto di disegnarlo! In realtà questo è ciò che fa la libreria Adafruit. Inizializza la memoria del modulo (la rappresentazione in memoria dell'hardware del display) con il logo di questa azienda. Se non vuoi vederlo durante l'inizializzazione, puoi provare a chiamare la funzione display.clearDisplay() subito prima di chiamare display.display() nella tua funzione di configurazione. Questa funzione, come suggerisce il nome, cancella completamente il display.

#includere

Adafruit_SSD1306 display(4); void setup() { display.begin(SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay(); display.display(); } ciclo vuoto() { }

In base alla documentazione della libreria Adafruit_SSD1306, è possibile utilizzare diverse funzioni fornite da questa classe per disegnare sul display o manipolare direttamente i pixel su di esso. Nelle prossime sezioni cercheremo di presentare un esempio per ciascuno di essi in modo che possiate avere un'idea del modo in cui funziona. La maggior parte di questi esempi mostrerà solo un semplice contenuto statico, quindi possiamo semplicemente inserirli nella nostra funzione setup() (dopo il codice di inizializzazione). In questo modo verrebbe eseguito solo una volta e rimane lì.

Passaggio 8: visualizzare un testo semplice

Per visualizzare un testo, possiamo usare la semplice funzione display.println() della libreria. Accetta il testo come stringa e cerca di visualizzarlo. È importante sapere che dobbiamo dire alla biblioteca dove presenteremo il testo sul display. Ogni pixel sul display ha una coordinata che è specificata con una X e una Y. La X aumenta da sinistra a destra e Y aumenta dall'alto verso il basso. L'angolo in alto a sinistra dello schermo è (X=0, Y=0) e l'angolo in basso a destra è (X=127, Y=63). Ho annotato le coordinate degli angoli sulla prima foto. Possiamo usare la funzione display.setCursor() per specificare dove sul display andremo a visualizzare il testo.

Un'altra proprietà del testo è il suo colore. Possiamo specificare il colore usando display.setTextColor() come mostrato nel seguente esempio.

display.clearDisplay();

display.setTextColor(BIANCO); display.setCursor(35, 30); display.println("Ciao mondo!"); display.display();

Possiamo anche usare la funzione display.write() per visualizzare un singolo carattere. Accetta un codice carattere come tipo uint8_t e visualizza il carattere corrispondente a quel codice sulla stringa. Ad esempio, se vogliamo visualizzare la stessa stringa utilizzando questa funzione, possiamo utilizzare il seguente frammento:

display.clearDisplay();

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

È anche possibile disegnare testi in colore nero con sfondo bianco. Per fare ciò, devi chiamare la funzione display.setTextColor come di seguito:

display.clearDisplay();

// Imposta il colore su nero con sfondo bianco display.setTextColor(BLACK, WHITE); display.setCursor(25, 30); display.println("Testo invertito!"); display.display();

Hai anche la possibilità di impostare la dimensione del testo usando la funzione display.setTextSize(). Accetta un numero intero come dimensione. Maggiore è il numero, più grande sarà il testo. La dimensione più piccola è 1 che è la dimensione predefinita dei testi. Il seguente codice cerca di scrivere la lettera "A" in 6 diverse dimensioni:

display.clearDisplay();

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

Passaggio 9: disegnare forme di base

Disegnare forme di base come rettangolo, cerchio, triangolo, linea o punto è molto semplice e c'è una funzione dedicata per ognuna.

Linea di disegno

Per disegnare una linea puoi chiamare display.drawLine(startX, startY, endX, endY, color). Ad esempio, il codice seguente disegna una linea diagonale sullo schermo in modo che formino una grande X:

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();

È possibile accedere alla larghezza e all'altezza del display utilizzando le funzioni display.width() e display.height(). In questo modo il tuo codice sarebbe indipendente dalle dimensioni dello schermo.

Rettangolo di disegno

La funzione per disegnare un rettangolo è display.drawRect(upperLeftX, upperLeftY, larghezza, altezza, colore). Ecco il codice che disegna tre rettangoli in alcuni punti casuali:

display.clearDisplay();

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

Chiamando display.fillRect(upperLeftX, upperLeftY, width, height, WHITE) puoi disegnare un rettangolo riempito con il colore specificato. Anche la terza funzione in questo esempio è display.drawRoundRect(upperLeftX, upperLeftY, width, height, cornerRadius, color) che come puoi vedere in figura serve per disegnare un rettangolo con gli angoli arrotondati. Accetta un parametro extra prima del colore che è un numero intero che indica il raggio dell'angolo. Maggiore è il valore, più arrotondato è l'angolo. Ha anche una funzione di riempimento corrispondente denominata display.drawFillRoundRect che penso tu possa indovinare cosa fa.

Cerchio di disegno

La funzione è display.drawCircle(centerX, centerY, raggio, colore). Ecco un esempio che disegna una forma simile a una faccina:

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

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

Come i rettangoli, puoi usare la funzione display.fillCircle per disegnare un cerchio riempito con il colore dato.

Disegno triangolo

Ahh, ancora una funzione chiamata display.drawTriangle(poin1X, point1Y, point2X, point2Y, point3X, point3Y, color) e il corrispondente display.fillTriangle che disegna un triangolo pieno.

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

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

Disegna un punto

Puoi anche colorare un punto specifico (chiamato pixel) sullo schermo tramite la funzione display.drawPixel(pixelX, pixelY, color).

display.drawPixel(20, 35, BIANCO);

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

Passaggio 10: disegno dell'immagine

Disegnare un'immagine è diverso e un po' complicato. Poiché il modulo di visualizzazione è monocolore, dobbiamo prima convertire la nostra immagine in un formato chiamato bitmap monocolore (chiamato anche bianco e nero). In tale formato, ogni pixel dell'immagine viene presentato con 0 o 1. Gli 1 rappresentano l'esistenza del colore e gli 0 indicano uno spazio vuoto. Puoi vedere un esempio del logo Arduino in questo formato in cima a questa sezione. La funzione per disegnare un'immagine bitmap è display.drawBitmap(topLeftX, topLeftY, imageData, width, height, color). Il parametro imageData è una matrice di numeri in byte. Ogni byte ha 8 bit, quindi ogni byte contiene i dati di 8 pixel dell'immagine. Specificando la larghezza e l'altezza dell'immagine, la funzione drawBitmap saprà da quale bit inizia la riga di pixel successiva.

La soluzione che ho scelto per convertire la mia immagine in questo formato è stata quella di utilizzare prima uno dei "convertitori da immagine a ASCII" online (ad esempio https://my.asciiart.club) per convertire la mia immagine in un insieme di caratteri ASCII e quindi sostituire i caratteri usati per lo spazio vuoto da 0 e gli altri da 1. Questo è quello che vedi sotto. Puoi pensare a ogni 0 e 1 come un pixel sul display. Quindi la dimensione dell'immagine non deve superare la nostra dimensione del display che è 128x64.

Nota: l'utilizzo di questa tecnica ASCII non è un approccio consigliato perché a causa delle proporzioni dei caratteri l'immagine sarà deformata (i caratteri non sono un quadrato). Ho provato questa tecnica solo perché rende più facile convertire l'immagine nel formato richiesto. Altrimenti sarebbe possibile ottenere il miglior risultato tramite qualche programma o utilizzando alcune applicazioni di utilità che sono completamente fuori dagli scopi di questo testo.

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

Ora dovremmo dividere ogni riga per 8, che rappresenta un byte e memorizzarli in un array come di seguito:

static const unsigned char PROGMEM arduino_logo ={

B00000000, B00000000, B00000111, B111111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B111111111, B11111111, B111111110, B00000000, B00000000, … // continua fino alla fine dell'immagine };

Quindi possiamo disegnarlo sul display chiamando la funzione drawBitmap.

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

Passaggio 11: risoluzione dei problemi

Questo è stato un lungo tutorial e quindi è molto probabile che qualcosa vada storto. Ecco l'elenco di alcuni errori comuni che potresti riscontrare durante la configurazione del modulo display OLED per il tuo progetto (alcuni di questi si sono verificati per me durante la preparazione di questo tutorial).

Non viene visualizzato nulla

Questo potrebbe accadere per molte ragioni, quindi suggerisco di controllare il seguente elenco che è in ordine che possa verificarsi nel tuo progetto:

L'indirizzo I2C è probabilmente sbagliato

Assicurati di aver impostato l'indirizzo che hai nel codice i2c-scanner nella funzione display.begin() quando configuri il tuo oggetto di visualizzazione.

SCL e SDA sono collegati in modo errato

Questo in realtà è successo per me. Se stai usando Arduino Uno, devi ricontrollare le tue connessioni per assicurarti che siano collegate come le mie. Se stai usando un'altra edizione di Arduino (ad esempio Mega, Leonardo, ecc.), Devi sapere che potrebbero avere il loro I2C impostato su altri pin. Puoi verificarlo nella documentazione della libreria Wire.

Stai disegnando qualcosa fuori dall'area visibile

Questo è un problema software. È molto comune quando si utilizzano le funzioni di disegno per calcolare male alcune coordinate e quindi il disegno sarebbe deformato o, nel peggiore dei casi, potrebbe essere completamente fuori scena. Rivedi i tuoi calcoli e prova a fare un disegno passo passo per vedere cosa sta succedendo.

Il testo non viene visualizzato affatto

Hai dimenticato di impostare il colore del testo o lo hai impostato su un valore sbagliato

Devi chiamare setTextColor prima di disegnare testi. Altrimenti non hai errori, ma non vedrai nulla sul display. Inoltre potresti aver impostato il colore del testo uguale al colore di sfondo.

Stai usando un carattere molto grande

Se imposti la dimensione del testo su un valore molto grande, è possibile che i caratteri escano completamente dall'area visibile.

C'è un errore di compilazione sulla dimensione del display

Questo è successo anche a me e penso che accadrà per la maggior parte di voi. È a causa dei valori costanti della dimensione di visualizzazione che sono definiti all'interno del file di intestazione Adafruit_SSD1306.h che includiamo in cima al nostro script. Questo file si trova in {cartella-progetto}\libraries\Adafruit_SSD1306\Adafruit_SSD1306.h. Se apri questo file, noterai che è presente una sezione di commento come di seguito in cui viene descritto che è necessario decommentare solo la costante che rappresenta le dimensioni del modulo di visualizzazione OLED. Per un modulo display 128x64, la riga #define SSD1306_128_64 non dovrebbe essere commentata.

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

Display SSD1306 ------------------------------------------------ ---------------------- Il driver viene utilizzato in più display (128x64, 128x32, ecc.). Selezionare il display appropriato di seguito per creare un framebuffer di dimensioni appropriate, ecc. SSD1306_128_64 Display a 128x64 pixel SSD1306_128_32 Display a 128x32 pixel SSD1306_96_16 ------------- --------------------------------------------*/ #define SSD1306_128_64 / / #define SSD1306_128_32 // #define SSD1306_96_16 /*======================================= ===============================*/

Passaggio 12: cosa fare dopo?

Il display OLED come modulo di output può darti una grande opportunità per fornire un'interfaccia dall'aspetto professionale ai tuoi progetti di hobby. Puoi provare a seguire le idee come punto di partenza per visualizzare dati significativi su di esso o aiutare l'utente a sapere cosa sta succedendo o se ha bisogno di fare qualcosa. Sarebbe molto più chiaro per un utente leggere un messaggio su un display che interpretare lo stato di un progetto/dispositivo tramite alcuni LED.

Quello che puoi fare come punto di partenza potrebbe essere:

• Leggere un valore del sensore di temperatura e visualizzarlo sul modulo OLED. Puoi aggiungere un sensore di pressione o umidità e creare un progetto di stazione meteorologica completamente funzionale.
• Prova a disegnare qualcosa sul modulo display usando un modulo joystick come dispositivo di input.
• Prova a disegnare un'animazione sul display con una sequenza di chiamate di funzioni di disegno/ritardo o interrupt di Arduino
• Mostra il tuo logo personalizzato all'avvio del sistema (invece del logo Adafruit)

Non dimenticare di dirmi nei commenti, cosa faresti (o hai già fatto) usando il modulo display OLED.