Diversión con pantalla OLED y Arduino: 12 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:40

Estoy bastante seguro de que definitivamente ha oído hablar de la tecnología de pantalla OLED. Es relativamente nuevo y ofrece una mejor calidad que la antigua tecnología LCD. En este tutorial queremos revisar los pasos necesarios para mostrar datos en uno de los módulos de pantalla OLED de un solo color más comunes disponibles en el mercado. Intentaré explicar las funcionalidades proporcionadas por la biblioteca Adafruit correspondiente para mostrar datos en este módulo.

Paso 1: ¿Qué módulos OLED vamos a utilizar?

Los módulos OLED están disponibles en una amplia variedad de tamaños y características. El que vamos a utilizar en este tutorial es un módulo OLED monocromo de 128x64. Este tipo de módulo está disponible en los siguientes tamaños (en el orden que ves en las imágenes):

• 128 x 64
• 128x32
• 96x16
• 64 x 48
• 64x32

Como todos estos módulos admiten el protocolo I2C como medio de comunicación, el código y cableado de todos ellos es exactamente el mismo. La única diferencia es que debes considerar el tamaño de la pantalla en tu código para que el contenido que vas a mostrar se ajuste correctamente.

Paso 2: I2C en pocas palabras

El circuito interintegrado (IIC) que normalmente se llama I2C (I cuadrado C) desarrollado por Philips en los años 80 como un bus de intercambio de datos utilizado para transferir datos entre la unidad central de procesamiento (CPU) o la unidad de microcontrolador (MCU) de un dispositivo y chips periféricos. Básicamente, estaba dirigido a aplicaciones de televisión. Debido a su simplicidad, se hizo tan popular que después de un tiempo se convirtió en uno de los principales mecanismos de transferencia de datos para CPU y MCU y dispositivos periféricos que no son necesariamente parte de la misma placa PCB y están conectados a ella a través de cables (por ejemplo, sensores, módulos de visualización, etc.).

I2C consta de un bus de comunicación hecho de dos cables que admite la transferencia de datos bidireccional entre un maestro y varios dispositivos esclavos. Por lo general, el nodo maestro está a cargo de controlar el bus, lo que en realidad se hace generando una señal de sincronización en la línea de reloj en serie (SCL). Es una señal que el maestro enviaría continuamente durante la transferencia y todos los demás nodos conectados al bus la usarán para sincronizar su comunicación y detectar la velocidad del bus. Los datos se transfieren entre el maestro y el esclavo a través de una línea de datos en serie (SDA). La velocidad de transmisión puede ser de hasta 3,4 Mbps. Todos los dispositivos que deseen transferir datos a través de I2C deben tener una dirección única y pueden funcionar como transmisores o receptores según la función del dispositivo. Por ejemplo, un módulo de pantalla OLED es un receptor que acepta algunos datos y los muestra, mientras que un sensor de temperatura es un transceptor que envía la temperatura capturada a través del bus I2C. Normalmente, un dispositivo maestro es el dispositivo que inicia una transferencia de datos en el bus y genera las señales de reloj para permitir la transferencia. Durante esa transferencia, cualquier dispositivo direccionado por este maestro se considera esclavo y lee esos datos.

Cuando un nodo quiere enviar algunos datos, el primer byte de los datos debe ser la dirección del receptor y luego vienen los datos reales. Esto significa que para enviar datos a un dispositivo de salida usando I2C (por ejemplo, módulo de pantalla OLED I2C), primero debemos encontrar su dirección I2C y esto es lo que haremos primero en los siguientes pasos.

Si está interesado en conocer más detalles y teorías sobre el bus I2C, puede utilizar las siguientes referencias:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Paso 3: Módulos y componentes necesarios

Aquí puede encontrar la lista de componentes que necesitaría para completar este tutorial:

Enlaces de eBay:

• 1 x Arduino Uno:
• 1 x módulo OLED 128x64:
• 4 x cable Dupont:
• 1 x Mini placa de pruebas sin soldadura:

Enlaces de Amazon.com:

• 1 x Arduino Uno:
• 1 x módulo OLED 128x64:
• 4 x cable Dupont:
• 1 x Mini placa de pruebas sin soldadura:

Paso 4: Cableado del módulo de pantalla OLED a Arduino

Una nota importante sobre los dispositivos habilitados para I2C es que la forma en que debe conectarlos a Arduino es la misma. Esto se debe a que Arduino ejecuta su comunicación I2C solo en pines específicos. En este tutorial estoy usando Arduino Uno. El Arduino Uno usa el pin A5 como SCK y A4 como SDA. Entonces podemos conectar el módulo de pantalla OLED a Arduino Uno como se muestra en la vista esquemática. Como puede notar en la imagen que tomé de mi módulo de pantalla OLED, el conector para VCC y GND son diferentes a la vista esquemática. Recuerde revisar las etiquetas de los pines en sus módulos para asegurarse de que los está conectando de la manera correcta.

Solo necesitamos 4 pines que deben conectarse como se muestra a continuación:

Arduino VCC -> Módulo OLED VCC

Arduino GND -> Módulo OLED GND

Arduino 4 -> Módulo OLED SDA

Arduino 5 -> Módulo OLED SCK

Paso 5: encontrar la dirección del módulo de pantalla

Como primer paso para conectarse a un dispositivo habilitado para I2C, debe tener la dirección del módulo. Para hacerlo, después de conectar el módulo a su Arduino, simplemente debe cargar el código adjunto en su Arduino. Este código incorpora la biblioteca Wire, que es una biblioteca incluida con Arduino IDE que maneja la comunicación I2C. Intenta escanear los dispositivos I2C conectados y envía su dirección a través del puerto serie a su computadora. Para que pueda acceder a su salida a través de la herramienta Serial Monitor en Arduino IDE. La versión original está disponible en Arduino Playground). También puede verlo de una manera más legible en mi Arduino Editor en línea. No espere que se muestre nada en la pantalla mientras se ejecuta este código.

Como puede ver en la imagen, mi módulo está vinculado a la dirección 0x3C. Normalmente, todos los dispositivos de una línea de productos específica (por ejemplo, todos los módulos OLED de 128x64) tienen la misma dirección.

La dirección de los dispositivos I2C está limitada de 1 a 126. Este código simplemente intenta conectarse a cada dispositivo en orden (sin transmitir ningún dato) y luego verifica si hubo algún error reportado por la biblioteca subyacente al conectarse a la dirección proporcionada. Si no hay ningún error, imprime la dirección como un módulo disponible para conectar. También debe tenerse en cuenta que las primeras 15 direcciones están reservadas, por lo que salta sobre ellas y solo imprime las que están por encima de este rango. Recuerde que la dirección de estos módulos I2C está codificada en el dispositivo y no se puede cambiar. Por lo tanto, sería una buena idea escribirlo en algún lugar o poner una etiqueta en el módulo cuando lo vuelva a colocar en el estante de su laboratorio para que la próxima vez no sea necesario ejecutar el código del escáner. Sin embargo, no es un procedimiento complicado;)

Paso 6: Instalación de las bibliotecas necesarias para mostrar datos en el módulo OLED

La biblioteca Wire puede manejar comunicaciones de bajo nivel con dispositivos I2C. Cuando desee conectarse a un dispositivo específico para leer / escribir datos desde / hacia él, normalmente usaría una biblioteca proporcionada por la compañía que originalmente construyó ese módulo. Esta biblioteca maneja todos los detalles de comunicación I2C con un módulo dado y nos permite concentrarnos más en nuestro negocio, que en este caso muestra los datos de la manera que queremos.

Adafruit, la empresa que fabrica la versión original de dichos módulos de pantalla, proporciona una biblioteca llamada Adafruit SSD1306 para mostrar datos en estas pantallas monocromas. Entonces, antes de comenzar a codificar, tenemos que instalar esta biblioteca a través del Administrador de bibliotecas (accesible a través del menú Sketch> Incluir biblioteca> Administrar bibliotecas …) en Arduino IDE. También hay otra biblioteca llamada Adafruit GFX Library que maneja más material gráfico de bajo nivel y es utilizada internamente por Adafruit SSD1306. Debe tener ambos instalados en su Arduino IDE como puede ver en las imágenes.

Paso 7: inicialización del módulo de visualización

El módulo de dibujo en pantalla está envuelto en una clase llamada Adafruit_SSD1306. La definición de esta clase está en la biblioteca Adafruit, por lo que primero debemos incluir esa biblioteca. Luego, primero tenemos que crear una instancia de esta clase. El constructor de esta clase toma el número de puerto en el que se puede restablecer la pantalla, que es el pin 4 (conectado a SCK). Esta parte del código debe ubicarse al principio del archivo (fuera de las funciones setup () y loop ()).

#incluir

Pantalla Adafruit_SSD1306 (4);

Ahora, dentro de la función setup (), debemos llamar a la función de inicio del objeto de visualización pasando nuestra dirección I2C como se muestra a continuación (el SSD1306_SWITCHCAPVCC es un valor constante que especifica el tipo de fuente de alimentación a la biblioteca):

configuración vacía () {

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.display (); } void loop () {} // el bucle puede estar vacío por ahora

Ahora el objeto de visualización está listo y podemos llamar a sus funciones (por ejemplo, display.write (), display.drawLine, etc.). La nota importante es que siempre que dibujamos algo llamando a nuestro objeto de visualización, necesitamos llamar a la función display.display () para que el dibujo real suceda en el nivel de hardware. Esto se debe principalmente al hecho de que las funciones de dibujo que llamamos, simplemente actualizan la representación "en memoria" de la pantalla por razones de rendimiento. De hecho, almacena en caché los cambios en la memoria. Por lo tanto, siempre debemos recordar llamar a la función display () cuando terminemos de dibujar algo en la pantalla.

display.write (…); // sigue actualizándose en la memoria

display.drawLine (…); // sigue actualizándose en la memoria. display.display (); // elimina todos los cambios en el hardware de la pantalla

Si intenta cargar su código en este paso, notará que se mostrará el logotipo de Adafruit Industries. ¡Quizás se pregunte quién le ha pedido que lo dibuje! En realidad, esto es lo que hace la biblioteca Adafruit. Inicializa la memoria del módulo (la representación en memoria del hardware de pantalla) con el logo de esta empresa. Si no quiere ver eso durante la inicialización, puede intentar llamar a la función display.clearDisplay () justo antes de llamar a display.display () en su función de configuración. Esta función, como su nombre indica, borra completamente la pantalla.

#incluir

Pantalla Adafruit_SSD1306 (4); configuración vacía () {display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.display (); } bucle vacío () {}

Según la documentación de la biblioteca Adafruit_SSD1306, puede usar diferentes funciones proporcionadas por esta clase para dibujar en la pantalla o manipular directamente los píxeles en ella. En las próximas secciones intentaremos presentar un ejemplo para cada uno de ellos para que puedas tener una idea de cómo funciona. La mayoría de estos ejemplos mostrarán solo un contenido estático simple, por lo que podemos ponerlos dentro de nuestra función setup () (después del código de inicialización). Al hacerlo, se ejecutará solo una vez y permanecerá allí.

Paso 8: muestra un texto simple

Para mostrar un texto, podemos usar la función simple display.println () de la biblioteca. Acepta el texto como una cadena e intenta mostrarlo. Es importante saber que tenemos que decirle a la biblioteca en qué parte de la pantalla vamos a presentar el texto. Cada píxel de la pantalla tiene una coordenada que se especifica con una X y una Y. La X aumenta de izquierda a derecha e Y aumenta de arriba a abajo. La esquina superior izquierda de la pantalla es (X = 0, Y = 0) y la esquina inferior derecha es (X = 127, Y = 63). Anoté las coordenadas de las esquinas en la primera imagen. Podemos usar la función display.setCursor () para especificar en qué parte de la pantalla mostraremos el texto.

Otra propiedad del texto es su color. Podemos especificar el color usando display.setTextColor () como se muestra en la siguiente muestra.

display.clearDisplay ();

display.setTextColor (BLANCO); display.setCursor (35, 30); display.println ("¡Hola mundo!"); display.display ();

También podemos usar la función display.write () para mostrar un solo carácter. Acepta un código de carácter como un tipo uint8_t y muestra el carácter correspondiente a ese código en la cadena. Como ejemplo, si queremos mostrar la misma cadena usando esta función, podemos usar el siguiente fragmento:

display.clearDisplay ();

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

También es posible dibujar textos en color negro con fondo blanco. Para hacerlo, debe llamar a la función display.setTextColor como se muestra a continuación:

display.clearDisplay ();

// Establece el color en negro con un fondo blanco display.setTextColor (BLACK, WHITE); display.setCursor (25, 30); display.println ("¡Texto invertido!"); display.display ();

También tiene la opción de configurar el tamaño del texto usando la función display.setTextSize (). Acepta un número entero como tamaño. Cuanto mayor sea el número, mayor será el texto. El tamaño más pequeño es 1, que es el tamaño predeterminado de los textos. El siguiente código intenta escribir la letra "A" en 6 tamaños diferentes:

display.clearDisplay ();

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

Paso 9: Dibujar formas básicas

Dibujar formas básicas como rectángulo, círculo, triángulo, línea o punto es muy fácil y hay una función dedicada para cada uno.

Línea de dibujo

Para dibujar una línea, puede llamar a display.drawLine (startX, startY, endX, endY, color). Por ejemplo, el siguiente código dibuja líneas diagonales en la pantalla para que formen una gran X:

display.clearDisplay ();

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

Puede acceder al ancho y alto de la pantalla mediante las funciones display.width () y display.height (). Al hacerlo, su código sería independiente del tamaño de la pantalla.

Rectángulo de dibujo

La función para dibujar un rectángulo es display.drawRect (upperLeftX, upperLeftY, width, height, color). Aquí está el código que dibuja tres rectángulos en algunos lugares aleatorios:

display.clearDisplay ();

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

Al llamar a display.fillRect (upperLeftX, upperLeftY, width, height, WHITE) puede dibujar un rectángulo relleno con el color especificado. También la tercera función en este ejemplo es display.drawRoundRect (upperLeftX, upperLeftY, width, height, cornerRadius, color) que como puedes ver en la imagen se usa para dibujar un rectángulo con esquinas redondeadas. Acepta un parámetro adicional antes del color que es un número entero que indica el radio de la esquina. Cuanto mayor sea el valor, más redonda será la esquina. También tiene una función de relleno correspondiente llamada display.drawFillRoundRect que creo que puedes adivinar lo que hace.

Círculo de dibujo

La función es display.drawCircle (centerX, centerY, radius, color). Aquí hay un ejemplo que dibuja una forma similar a una carita sonriente:

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

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

Al igual que los rectángulos, puede usar la función display.fillCircle para dibujar un círculo relleno con el color dado.

Triángulo de dibujo

Ahh, nuevamente una función llamada display.drawTriangle (poin1X, point1Y, point2X, point2Y, point3X, point3Y, color) y display.fillTriangle correspondiente que dibuja un triángulo relleno.

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

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

Dibujar un punto

También puede colorear un punto específico (que se llama píxel) en la pantalla a través de la función display.drawPixel (pixelX, pixelY, color).

display.drawPixel (20, 35, BLANCO);

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

Paso 10: Dibujo de la imagen

Dibujar una imagen es diferente y un poco complicado. Como el módulo de visualización es monocolor, primero debemos convertir nuestra imagen a un formato llamado mapa de bits monocromático (también llamado blanco y negro). En tal formato, cada píxel de la imagen se presenta con 0 o 1. El 1 representa la existencia del color y el 0 significa un espacio vacío. Puede ver un ejemplo del logotipo de Arduino en este formato en la parte superior de esta sección. La función para dibujar una imagen de mapa de bits es display.drawBitmap (topLeftX, topLeftY, imageData, width, height, color). El parámetro imageData es una matriz de números en bytes. Cada byte tiene 8 bits, por lo que cada byte contiene los datos de 8 píxeles de la imagen. Al especificar el ancho y el alto de la imagen, la función drawBitmap sabrá desde qué bit comienza la siguiente fila de píxeles.

La solución que elegí para convertir mi imagen a este formato fue usar primero uno de los "convertidores de imagen a ASCII" en línea (por ejemplo, https://my.asciiart.club) para convertir mi imagen a un conjunto de caracteres ASCII y luego reemplazar los caracteres utilizados para el espacio vacío por 0 y otros por 1. Eso es lo que ve a continuación. Puede pensar en cada 0 y 1 como un píxel en la pantalla. Por lo tanto, el tamaño de la imagen no debe exceder el tamaño de nuestra pantalla, que es 128x64.

Nota: El uso de esta técnica ASCII no es un enfoque recomendado porque debido a la relación de aspecto de los caracteres, su imagen se deformará (los caracteres no son un cuadrado). Probé esta técnica solo porque facilita la conversión de la imagen al formato requerido. De lo contrario, sería posible lograr el mejor resultado a través de alguna programación o utilizando algunas aplicaciones de utilidad que están completamente fuera del alcance de este texto.

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

Ahora debemos dividir cada línea por 8, lo que representa un byte y almacenarlos en una matriz como se muestra a continuación:

static const unsigned char PROGMEM arduino_logo = {

B00000000, B00000000, B00000111, B11111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B11111111, B11111110, B00000000, B00000000,… // continuar hasta el final de la imagen};

Entonces podemos dibujarlo en la pantalla llamando a la función drawBitmap.

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

Paso 11: solución de problemas

Este fue un tutorial largo, por lo que es muy probable que algo salga mal. Aquí está la lista de algunos errores comunes que puede encontrar al configurar el módulo de pantalla OLED para su proyecto (algunos de ellos me sucedieron mientras preparaba este tutorial).

No se muestra nada en absoluto

Esto podría suceder por muchas razones, por lo que sugiero que verifique la siguiente lista que está en el orden en que puede ocurrir en su proyecto:

La dirección I2C probablemente sea incorrecta

Asegúrese de haber configurado la dirección que obtuvo en el código del escáner i2c en la función display.begin () al configurar su objeto de visualización.

SCL y SDA están conectados de forma incorrecta

En realidad, esto me pasó a mí. Si está usando Arduino Uno, entonces debe verificar sus conexiones nuevamente para asegurarse de que estén conectadas igual que las mías. Si está utilizando otra edición de Arduino (por ejemplo, Mega, Leonardo, etc.), debe saber que pueden tener su I2C configurado en otros pines. Puede consultarlo en la documentación de la biblioteca Wire.

Estás sacando algo del área visible

Este es un problema de software. Es muy común cuando se utilizan funciones de dibujo para calcular mal algunas coordenadas y, por lo tanto, su dibujo se deformaría o, en el peor de los casos, podría estar completamente fuera de escena. Revise sus cálculos e intente hacer un dibujo paso a paso para ver qué está pasando.

El texto no se muestra en absoluto

Olvidó establecer el color del texto o lo estableció en un valor incorrecto

Debe llamar a setTextColor antes de dibujar textos. De lo contrario, no obtendrá errores, pero no verá nada en pantalla. Además, es posible que haya establecido el mismo color del texto que el color de fondo.

Estás usando una fuente muy grande

Si establece el tamaño del texto en un valor muy grande, es posible que los caracteres se salgan completamente del área visible.

Hay un error de compilación sobre el tamaño de la pantalla

Esto también me pasó a mí y creo que les pasaría a la mayoría de ustedes. Es debido a los valores constantes de tamaño de visualización que se definen dentro del archivo de encabezado Adafruit_SSD1306.h que incluimos en la parte superior de nuestro script. Este archivo se encuentra en {your-project-folder} libraries / Adafruit_SSD1306 / Adafruit_SSD1306.h. Si abre este archivo, notará que hay una sección de comentarios como la siguiente en la que se describe que debe descomentar solo la constante que representa el tamaño de su módulo de pantalla OLED. Para módulos de pantalla de 128x64, la línea #define SSD1306_128_64 debe estar sin comentarios.

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

Pantallas SSD1306 ------------------------------------------------ ---------------------- El controlador se utiliza en varias pantallas (128x64, 128x32, etc.). Seleccione la pantalla adecuada a continuación para crear un framebuffer de tamaño adecuado, etc. SSD1306_128_64 Pantalla de 128x64 píxeles SSD1306_128_32 Pantalla de 128x32 píxeles SSD1306_96_16 --------------------------- -------------------------------------------- * / #define SSD1306_128_64 / / #define SSD1306_128_32 // #define SSD1306_96_16 / * ======================================= =============================== * /

Paso 12: ¿Qué hacer a continuación?

La pantalla OLED como módulo de salida puede brindarle una gran oportunidad para proporcionar una interfaz de aspecto profesional para sus proyectos de hobby. Puede intentar seguir las ideas como punto de partida para mostrar datos significativos o ayudar al usuario a saber qué está pasando o si necesitaba hacer algo. Sería mucho más claro para un usuario leer un mensaje en una pantalla que interpretar el estado de un proyecto / dispositivo a través de algunos LED.

Lo que puede hacer como punto de partida podría ser:

• Leer un valor de sensor de temperatura y mostrarlo en el módulo OLED. Puede agregarle un sensor de presión o humedad y crear un proyecto de estación meteorológica completamente funcional.
• Intente dibujar algo en el módulo de visualización utilizando un módulo de joystick como dispositivo de entrada.
• Intente dibujar una animación en la pantalla mediante una secuencia de llamadas de función de dibujo / retardo o interrupción de Arduino
• Muestre su logotipo personalizado en el inicio de su sistema (en lugar del logotipo de Adafruit)

No olvide decirme en los comentarios, qué haría (o ya lo hizo) usando el módulo de pantalla OLED.