Diversió amb pantalla OLED i Arduino: 12 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:11

Estic segur que definitivament heu sentit a parlar de la tecnologia de pantalla OLED. És relativament nou i ofereix una millor qualitat que la tecnologia LCD antiga. En aquest tutorial volem revisar els passos necessaris per mostrar dades en un dels mòduls de pantalla OLED de color més comuns disponibles al mercat. Intentaré explicar les funcionalitats que proporciona la biblioteca Adafruit corresponent per mostrar les dades d’aquest mòdul.

Pas 1: Quins mòduls OLED utilitzarem?

Els mòduls OLED estan disponibles en una gran varietat de mides i funcions. El que farem servir en aquest tutorial és un mòdul OLED de 128x64 monocrom. Aquest tipus de mòdul està disponible en les mides següents (per tal que es vegi a les imatges):

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

Com que tots aquests mòduls admeten el protocol I2C com a mitjà de comunicació, el codi i el cablejat de tots ells són exactament iguals. L’única diferència és que heu de tenir en compte la mida de la pantalla del vostre codi per tal que el contingut que esteu mostrant encaixi correctament.

Pas 2: I2C en poques paraules

El circuit inter-integrat (IIC) que normalment s’anomena I2C (I quadrat C) desenvolupat per Philips als anys 80 com a bus d’intercanvi de dades que s’utilitza per transferir dades entre la unitat central de processament (CPU) o la unitat de microcontrolador (MCU) d’un dispositiu i xips perifèrics. Bàsicament estava dirigit a aplicacions de TV. A causa de la seva simplicitat, es va fer tan popular que al cap d’una estona es va convertir en un dels mecanismes principals de transferència de dades per a CPUs i MCU i dispositius perifèrics que no són part necessària de la mateixa placa PCB i que hi estan connectats mitjançant filferro (per exemple, sensors, mòduls de visualització, etc.).

I2C consisteix en un bus de comunicació format per dos cables que admet la transferència bidireccional de dades entre un mestre i diversos dispositius esclaus. Normalment, el node mestre s'encarrega de controlar el bus, cosa que realment es realitza generant un senyal de sincronització a la línia de rellotge sèrie (SCL). És un senyal que el mestre enviaria contínuament durant la transferència i tots els altres nodes connectats al bus l’utilitzaran per sincronitzar la seva comunicació i detectar la velocitat del bus. Les dades es transfereixen entre el mestre i l'esclau a través d'una línia de dades en sèrie (SDA). La velocitat de transmissió pot ser de fins a 3,4 Mbps. Tots els dispositius que vulguin transferir dades mitjançant I2C haurien de tenir una adreça única i poden funcionar com a transmissor o receptor segons la funció del dispositiu. Per exemple, un mòdul de visualització OLED és un receptor que accepta algunes dades i les mostra, mentre que un sensor de temperatura és un transceptor que envia la temperatura captada mitjançant un bus I2C. Normalment, un dispositiu mestre és el dispositiu que inicia una transferència de dades al bus i genera els senyals de rellotge per permetre la transferència. Durant aquesta transferència, qualsevol dispositiu dirigit per aquest mestre es considera esclau i llegeix aquestes dades.

Quan un node vol enviar algunes dades, el primer byte de les dades hauria de ser l'adreça del receptor i, després, les dades reals. Això vol dir que per enviar dades a un dispositiu de sortida mitjançant I2C (per exemple, el mòdul de visualització OLED I2C) primer hauríem de trobar la seva adreça I2C i això és el que farem primer en els passos següents.

Si esteu interessats en conèixer més detalls i teories sobre el bus I2C, podeu utilitzar les següents referències:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Pas 3: mòduls i components necessaris

Aquí podeu trobar la llista de components que necessitareu per completar aquest tutorial:

Enllaços d'eBay:

• 1 x Arduino Uno:
• 1 x mòdul OLED 128x64:
• 4 x cable Dupont:
• 1 x Mini tauler de soldadura sense soldadura:

Enllaços Amazon.com:

• 1 x Arduino Uno:
• 1 x mòdul OLED 128x64:
• 4 x cable Dupont:
• 1 x Mini tauler de soldadura sense soldadura:

Pas 4: Connexió del mòdul de visualització OLED a Arduino

Una nota important sobre els dispositius compatibles amb I2C és que la forma en què els heu de connectar a Arduino són iguals. Això es deu al fet que Arduino només executa la seva comunicació I2C en pins específics. En aquest tutorial estic fent servir Arduino Uno. L'Arduino Uno utilitza el pin A5 com a SCK i A4 com a SDA. Per tant, podem connectar el mòdul de pantalla OLED a Arduino Uno tal com es mostra a la vista esquemàtica. Com podeu notar a la imatge que he fet del meu mòdul de pantalla OLED, el connector per a VCC i GND és diferent de la vista esquemàtica. Recordeu que heu de comprovar les etiquetes dels pins dels mòduls per assegurar-vos que la connecteu de manera correcta.

Només necessitem 4 pins que s’haurien de connectar de la manera següent:

Arduino VCC -> Mòdul OLED VCC

Arduino GND -> Mòdul OLED GND

Arduino 4 -> Mòdul OLED SDA

Arduino 5 -> Mòdul OLED SCK

Pas 5: trobar l'adreça del mòdul de visualització

Com a primer pas per connectar-vos a un dispositiu habilitat per a l'I2C, heu de tenir l'adreça del mòdul. Per fer-ho, després de connectar el mòdul al vostre Arduino, només heu de penjar el codi adjunt al vostre Arduino. Aquest codi incorpora la biblioteca Wire, que és una biblioteca inclosa amb Arduino IDE que gestiona la comunicació I2C. Intenta escanejar els dispositius I2C connectats i envia la seva adreça a través del port sèrie al vostre ordinador. Per tant, podeu accedir a la seva sortida a través de l'eina Serial Monitor a Arduino IDE. La versió original està disponible a Arduino Playground). També podeu veure-ho d’una manera més llegible al meu Arduino Editor en línia. No espereu que es mostri res a la pantalla mentre s’executa aquest codi.

Com podeu veure a la imatge, el meu mòdul està vinculat a l'adreça 0x3C. Normalment, tots els dispositius d’una línia de productes específica (per exemple, tots els mòduls OLED de 128x64) tenen la mateixa adreça.

Les adreces dels dispositius I2C estan limitades de l'1 al 126. Aquest codi simplement intenta connectar-se a cada dispositiu per ordre (sense transmetre cap dada) i després comprovar si hi ha hagut algun error informat per la biblioteca subjacent en connectar-se a l'adreça proporcionada. Si no hi ha cap error, imprimeix l'adreça com a mòdul disponible per connectar-te. També cal tenir en compte que les 15 primeres adreces estan reservades, de manera que salta per sobre d'elles i només imprimeix les que estan per sobre d'aquest interval. Recordeu que l'adreça d'aquests mòduls I2C està codificada al dispositiu i no es pot canviar. Per tant, seria una bona idea escriure-la en algun lloc o posar una etiqueta al mòdul quan la torneu a col·locar a la prestatgeria del laboratori, de manera que la pròxima vegada no s’hauria d’executar el codi de l’escàner. Tot i això no és un procediment complicat;)

Pas 6: Instal·lació de biblioteques necessàries per mostrar dades al mòdul OLED

La biblioteca Wire pot gestionar la comunicació de baix nivell amb dispositius I2C. Quan vulgueu connectar-vos a un dispositiu específic per llegir / escriure dades des de / cap a ell, normalment utilitzeu una biblioteca proporcionada per l'empresa que originalment ha construït aquest mòdul. Aquesta biblioteca gestiona tots els detalls de la comunicació I2C amb el mòdul donat i ens permetrà concentrar-nos més en el nostre negoci, que en aquest cas mostra les dades de la manera que desitgem.

Adafruit, l’empresa que fabrica la versió original d’aquests mòduls de visualització, proporciona una biblioteca anomenada Adafruit SSD1306 per mostrar dades en aquestes pantalles monocromàtiques. Per tant, abans d’iniciar la codificació, hem d’instal·lar aquesta biblioteca mitjançant el Gestor de biblioteques (accessible al menú Sketch> Inclou biblioteca> Gestiona les biblioteques …) a Arduino IDE. També hi ha una altra biblioteca anomenada Adafruit GFX Library que gestiona més coses gràfiques de baix nivell i que és utilitzada internament per Adafruit SSD1306. Cal tenir-los tots dos instal·lats al vostre IDE Arduino com podeu veure a les imatges.

Pas 7: inicialització del mòdul de visualització

El mòdul Dibuixar a la pantalla s'embolica en una classe anomenada Adafruit_SSD1306. La definició d’aquesta classe es troba a la biblioteca Adafruit, per tant, primer hem d’incloure aquesta biblioteca. Després, primer hem d’instanciar una instància d’aquesta classe. El constructor d'aquesta classe pren el número de port en què es podria restablir la pantalla, que és el pin 4 (connectat a SCK). Aquesta part del codi s’hauria de localitzar al principi del fitxer (fora de les funcions setup () i loop ()).

#incloure

Adafruit_SSD1306 display (4);

Ara dins de la funció setup () hauríem de trucar a la funció begin de l'objecte de visualització passant la nostra adreça I2C com es mostra a continuació (el SSD1306_SWITCHCAPVCC és un valor constant que especifica el tipus de font d'alimentació a la biblioteca):

configuració nul·la () {

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.display (); } void loop () {} // bucle pot estar buit per ara

Ara l’objecte de visualització està llest i podem trucar a les seves funcions (per exemple, display.write (), display.drawLine, etc.). La nota important és que cada vegada que dibuixem alguna cosa cridant al nostre objecte de visualització, hem de trucar a la funció display.display () per fer que el dibuix real passi a nivell de maquinari. Això es deu principalment al fet que les funcions de dibuix que anomenem, simplement actualitzen la representació "a la memòria" de la pantalla per motius de rendiment. En realitat, emmagatzema a la memòria cau els canvis. Per tant, sempre hem de recordar trucar a la funció display () quan acabem de dibuixar alguna cosa a la pantalla.

display.write (…); // continua actualitzant-se a la memòria

display.drawLine (…); // continua actualitzant-se a la memòria. display.display (); // buida tots els canvis al maquinari de la pantalla

Si intenteu penjar el vostre codi en aquest pas, notareu que es mostrarà el logotip d’Adafruit Industries. Us podeu preguntar qui li ha demanat que dibuixi això! En realitat, això és el que fa la biblioteca d'Adafruit. Inicialitza la memòria del mòdul (la representació en memòria del maquinari de la pantalla) amb el logotip d'aquesta empresa. Si no voleu veure-ho durant la inicialització, podeu provar de trucar a la funció display.clearDisplay () just abans de trucar a display.display () a la funció de configuració. Aquesta funció, com el seu nom indica, neteja completament la pantalla.

#incloure

Adafruit_SSD1306 display (4); configuració nul·la () {display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.display (); } bucle buit () {}

Basat en la documentació de la biblioteca Adafruit_SSD1306, podeu utilitzar diferents funcions proporcionades per aquesta classe per dibuixar a la pantalla o manipular directament els píxels que hi ha. A les següents seccions intentarem presentar un exemple per a cadascuna d'elles perquè tingueu una idea sobre el seu funcionament. La majoria d'aquests exemples mostraran només un contingut estàtic senzill, de manera que només podem posar-los dins de la nostra funció setup () (després del codi d'inicialització). En fer-ho, només s’executaria una vegada i s’hi manté.

Pas 8: mostra un text senzill

Per mostrar un text, podem utilitzar la senzilla funció display.println () de la biblioteca. Accepta el text com una cadena i intenta mostrar-lo. És important saber que hem d’indicar a la biblioteca on mostrarem el text a la pantalla. Tots els píxels de la pantalla tenen una coordenada que s’especifica amb una X i una Y. La X augmenta d’esquerra a dreta i Y augmenta de dalt a baix. L’angle superior esquerre de la pantalla és (X = 0, Y = 0) i l’angle inferior dret és (X = 127, Y = 63). Vaig assenyalar les coordenades de les cantonades de la primera imatge. Podem utilitzar la funció display.setCursor () per especificar on mostrarem el text a la pantalla.

Una altra propietat del text és el seu color. Podem especificar el color mitjançant display.setTextColor () tal com es mostra a la mostra següent.

display.clearDisplay ();

display.setTextColor (BLANC); display.setCursor (35, 30); display.println ("Hola món!"); display.display ();

També podem utilitzar la funció display.write () per mostrar un sol caràcter. Accepta un codi de caràcters com a tipus uint8_t i mostra el caràcter corresponent a aquest codi a la cadena. Com a exemple, si volem mostrar la mateixa cadena amb aquesta funció, podem utilitzar el fragment següent:

display.clearDisplay ();

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

També és possible dibuixar textos en color negre amb fons blanc. Per fer-ho, heu de trucar a la funció display.setTextColor de la manera següent:

display.clearDisplay ();

// Estableix el color en negre amb un fons blanc display.setTextColor (NEGRE, BLANC); display.setCursor (25, 30); display.println ("Text invertit!"); display.display ();

També teniu l’opció d’establir la mida del text mitjançant la funció display.setTextSize (). Accepta com a mida un nombre enter. Com més gran sigui el nombre, més gran serà el text. La mida més petita és 1, que és la mida predeterminada dels textos. El següent codi intenta escriure la lletra "A" en 6 mides diferents:

display.clearDisplay ();

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

Pas 9: Dibuixar formes bàsiques

Dibuixar formes bàsiques com rectangle, cercle, triangle, línia o punt és molt fàcil i hi ha una funció dedicada per a cadascuna.

Línia de dibuix

Per dibuixar una línia podeu trucar a display.drawLine (startX, startY, endX, endY, color). Per exemple, el següent codi dibuixa línies diagonals a la pantalla de manera que donen forma a una gran X:

display.clearDisplay ();

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

Podeu accedir a l’amplada i l’alçada de la pantalla mitjançant les funcions display.width () i display.height (). En fer-ho, el vostre codi seria independent de la mida de la pantalla.

Dibuix de rectangle

La funció per dibuixar un rectangle és display.drawRect (upperLeftX, upperLeftY, amplada, alçada, color). Aquí teniu el codi que dibuixa tres rectangles en alguns llocs aleatoris:

display.clearDisplay ();

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

En trucar a display.fillRect (upperLeftX, upperLeftY, width, height, WHITE) podeu dibuixar un rectangle ple de color especificat. La tercera funció d’aquest exemple també és display.drawRoundRect (upperLeftX, upperLeftY, width, height, cornerRadius, color) que, com podeu veure a la imatge, s’utilitza per dibuixar un rectangle amb cantonades rodones. Accepta un paràmetre addicional abans del color que és un nombre enter que indica el radi de la cantonada. Com més gran sigui el valor, més rodona serà la cantonada. També té una funció d’ompliment corresponent anomenada display.drawFillRoundRect que crec que podeu endevinar què fa.

Cercle de dibuix

La funció és display.drawCircle (centreX, centreY, radi, color). Aquí teniu un exemple que dibuixa una forma de somriure:

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

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

Igual que els rectangles, podeu utilitzar la funció display.fillCircle per dibuixar un cercle ple del color donat.

Dibuix de triangle

Ahh, novament una funció anomenada display.drawTriangle (poin1X, point1Y, point2X, point2Y, point3X, point3Y, color) i display.fillTriangle corresponent que dibuixa un triangle ple.

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

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

Dibuixa un punt

També podeu acolorir un punt específic (que s’anomena píxel) a la pantalla mitjançant la funció display.drawPixel (pixelX, pixelY, color).

display.drawPixel (20, 35, BLANC);

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

Pas 10: Dibuixar la imatge

Dibuixar una imatge és diferent i una mica complicat. Com que el mòdul de visualització és monocolor, primer hem de convertir la nostra imatge en un format anomenat mapa de bits mono color (també anomenat blanc i negre). En aquest format, cada píxel de la imatge es presenta amb 0 o 1. L'1 representa l'existència del color i 0 significa un espai buit. Podeu veure un exemple del logotip d'Arduino en aquest format a la part superior d'aquesta secció. La funció per dibuixar una imatge de mapa de bits és display.drawBitmap (topLeftX, topLeftY, imageData, amplada, alçada, color). El paràmetre imageData és una matriu de números en bytes. Cada byte té 8 bits, de manera que cada byte conté les dades de 8 píxels de la imatge. En especificar l'amplada i l'alçada de la imatge, la funció drawBitmap sabrà a partir de quin bit comença la següent fila de píxels.

La solució que vaig escollir per convertir la meva imatge en aquest format va ser utilitzar primer un dels "convertidors d'imatge a ASCII" en línia (per exemple, https://my.asciiart.club) per convertir la meva imatge a un conjunt de caràcters ASCII i després substituir-la els caràcters utilitzats per a l'espai buit per 0 i els altres per 1. Això és el que veieu a continuació. Podeu pensar en cada 0 i 1 com un píxel a la pantalla. Per tant, la mida de la imatge no hauria de superar la mida de pantalla que és 128x64.

Nota: No es recomana utilitzar aquesta tècnica ASCII perquè a causa de la relació d'aspecte dels caràcters la imatge es deformarà (els caràcters no són un quadrat). He provat aquesta tècnica només perquè facilita la conversió de la imatge al format requerit. En cas contrari, seria possible obtenir el millor resultat mitjançant alguna programació o mitjançant algunes aplicacions d’utilitat que quedin completament fora de l’abast d’aquest 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

Ara hauríem de dividir cada línia per 8, representant un byte i emmagatzemar-les en una matriu com es mostra a continuació:

static const unsigned char PROGMEM arduino_logo = {

B00000000, B00000000, B00000111, B11111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B11111111, B11111110, B00000000, B00000000;

Aleshores el podem dibuixar a la pantalla trucant a la funció drawBitmap.

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

Pas 11: resolució de problemes

Aquest va ser un llarg tutorial i, per tant, és molt probable que alguna cosa vagi malament. Aquí teniu la llista d’alguns errors comuns que podeu trobar en configurar el mòdul de visualització OLED per al vostre projecte (alguns d’ells em van passar mentre preparava aquest tutorial).

No s’està mostrant res

Això pot passar per molts motius, de manera que us suggereixo que consulteu la llista següent que està en ordre que es pugui produir al vostre projecte:

L’adreça I2C probablement és incorrecta

Assegureu-vos que heu definit l’adreça que teniu al codi d’escàner i2c a la funció display.begin () quan configureu l’objecte de visualització.

SCL i SDA estan connectats de manera equivocada

Això em va passar realment. Si feu servir Arduino Uno, haureu de tornar a comprovar les connexions per assegurar-vos que estiguin connectades igual que la meva. Si utilitzeu una altra edició Arduino (per exemple, Mega, Leonardo, etc.), heu de saber que és possible que tinguin el seu I2C ajustat a altres pins. Podeu consultar-lo a la documentació de la biblioteca de filferro.

Esteu traient alguna cosa de la zona visible

Aquest és un problema de programari. És molt comú quan s’utilitzen funcions de dibuix per calcular malament algunes coordenades, de manera que el dibuix es deformaria o, en el pitjor dels casos, pot estar completament fora de l’escena. Reviseu els càlculs i intenteu fer un dibuix pas a pas per veure què passa.

El text no es mostra en absolut

Heu oblidat definir el color del text o l’heu definit amb un valor incorrecte

Cal trucar a setTextColor abans de dibuixar textos. En cas contrari, no teniu cap error, però no veureu res a la pantalla. També és possible que hàgiu definit el color del text igual que el color de fons.

Feu servir un tipus de lletra molt gran

Si definiu la mida del text a un valor molt gran, és possible que els caràcters surtin completament de l'àrea visible.

Hi ha un error de compilació sobre la mida de la pantalla

Això també va passar per a mi i crec que passaria per a la majoria de vosaltres. És a causa dels valors constants de mida de visualització que es defineixen dins del fitxer de capçalera Adafruit_SSD1306.h que incloem a la part superior del nostre script. Aquest fitxer es troba a {your-project-folder} libraries / Adafruit_SSD1306 / Adafruit_SSD1306.h. Si obriu aquest fitxer, notareu que hi ha una secció de comentaris a continuació, en què es descriu que només heu de comentar la constant que representa la mida del mòdul de pantalla OLED. Per a mòduls de visualització de 128x64, la línia #define SSD1306_128_64 no s'ha de comentar.

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

Mostra SSD1306 ------------------------------------------------ ---------------------- El controlador s'utilitza en diverses pantalles (128x64, 128x32, etc.). Seleccioneu la pantalla adequada a continuació per crear un framebuffer de mida adequada, etc. SSD1306_128_64 Pantalla de 128x64 píxels SSD1306_128_32 Pantalla de 128x32 píxels SSD1306_96_16 --------------------------- -------------------------------------------- * / #define SSD1306_128_64 / / #define SSD1306_128_32 // #define SSD1306_96_16 / * ========================================= =============================== * /

Pas 12: què heu de fer a continuació?

La pantalla OLED com a mòdul de sortida us pot proporcionar una gran oportunitat per proporcionar una interfície d’aspecte professional als vostres projectes d’afició. Podeu provar de seguir idees com a punt de partida per mostrar-hi dades significatives o ajudar l’usuari a saber què passa o si necessitava fer alguna cosa. Seria molt més clar per a un usuari llegir un missatge en una pantalla que interpretar l’estat d’un projecte / dispositiu mitjançant alguns LED.

El que podeu fer com a punt de partida podria ser:

• Llegiu el valor del sensor de temperatura i mostreu-lo al mòdul OLED. Podeu afegir-hi un sensor de pressió o humitat i crear un projecte d’estació meteorològica totalment funcional.
• Proveu de dibuixar alguna cosa al mòdul de visualització mitjançant un mòdul de joystick com a dispositiu d’entrada.
• Proveu de dibuixar una animació a la pantalla mitjançant una seqüència de trucades de funció de retard / retard o interrupció Arduino
• Mostra el logotip personalitzat a l'inici del sistema (en lloc del logotip d'Adafruit)

No oblideu dir-me els comentaris, què faríeu (o que ja heu fet) amb el mòdul de pantalla OLED.