Pantalla OLED I2C Tutorial Arduino / NodeMCU: 15 pasos

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

El primer programa que escribes cuando comienzas a aprender un

El nuevo lenguaje de programación es: "¡Hola mundo!".

El programa en sí no hace más que imprimir un texto "Hola mundo" en la pantalla.

Entonces, ¿cómo hacemos que nuestro Arduino muestre el mensaje "¡Hola mundo!"?

En este video, le mostraré cómo comenzar con las pequeñas pantallas OLED I2C de 0.91 (128x32) y 0.96 (128x64).

Hay cientos de tutoriales en la web que explican lo mismo de diferentes maneras, pero no pude encontrar uno que me diga todo sobre la pantalla OLED y cómo usarla en diferentes escenarios. Me tomó un tiempo resolverlo todo. Entonces, pensé que debería crear un tutorial sobre lo que he aprendido y combinar todas las características y formas en que las pantallas OLED se pueden usar en nuestros proyectos.

Paso 1: Cosas que vamos a aprender hoy

En este video estaremos hablando de:

- ¿Qué es una pantalla OLED?

- Luego veremos más de cerca las pantallas OLED I2C de 0.91 (128x32) y 0.96 (128x64)

- A continuación, hablaremos sobre la instalación de la biblioteca Adafruit en su IDE de Arduino

- Luego conectaremos NodeMCU y Arduino a una pantalla OLED

- A continuación, veremos el código y mostraremos algunos gráficos y texto en él.

- También hablaremos sobre la aplicación de fuentes personalizadas y la visualización de imágenes.

- Luego conectaremos varios OLED a un microcontrolador usando el multiplexor I2C

- Finalmente, hablaremos sobre algunos errores comunes que las personas cometen al usar las pantallas OLED.

Paso 2: requisito de hardware

Para este tutorial necesitamos:

- Una placa de pruebas

- Pantallas OLED I2C I2C de 0,91 "(128x32) y 0,96" (128x64)

- Arduino UNO / NANO (lo que sea útil)

- NodeMCU

- Multiplexor TCA9548A I2C

- Pocos cables de conexión

- y un cable USB para cargar el código

Paso 3: ¿Qué es una pantalla OLED?

El diodo emisor de luz OLED u orgánico es un emisor de luz

diodo (LED) en el que la capa electroluminiscente emisiva es una película de compuesto orgánico (millones de pequeñas luces LED) que emite luz en respuesta a una corriente eléctrica.

Los OLED se utilizan para crear pantallas digitales en dispositivos como pantallas de televisión, monitores de computadora, sistemas portátiles como teléfonos móviles, consolas de juegos portátiles y PDA. Una pantalla OLED funciona sin luz de fondo porque emite luz visible.

Paso 4:

Hay muchos tipos de pantallas OLED disponibles en la

mercado basado en su

- Tamaños

- Color

- Marcas

- Protocolo

- SPI (interfaz periférica en serie) o I2C

- Esquema de control de matriz pasiva (PMOLED) o matriz activa (AMOLED)

En este tutorial, voy a hablar sobre cómo conectar el

pantallas OLDE I2C de color azul 0.91 (128x32 OLED) y 0.96 (128x64 OLED) a un Arduino NANO y NodeMCU. La tecnología de bus I2C utiliza solo 2 pines del MCU, por lo que tenemos montones disponibles para otros sensores.

Paso 5: mirada más de cerca

Echemos un vistazo más de cerca a estas dos pantallas.

En la parte posterior de estas pantallas hay montones de condensadores y resistencias SMD soldados a bordo; pero, como es un dispositivo I2C, solo nos preocupan estos 2 pines (SCL y SDA)

La pantalla se conecta a Arduino usando solo cuatro cables: dos para alimentación (VCC y GND) y dos para datos (reloj serie SCL y

SDA de datos en serie), lo que hace que el cableado sea muy simple. La conexión de datos es I2C (I²C, IIC o Inter-Integrated Circuit) y esta interfaz también se llama TWI (Two Wire Interface).

- Los pines incorporados pueden estar en un orden diferente, así que siempre verifique tres veces antes de conectarlo a su proyecto.

- El voltaje de operación está entre 3v y 5v, pero es mejor usar la guía de la hoja de datos del fabricante.

- A veces necesitamos usar 2 pantallas en nuestros proyectos. Entonces, ¿cómo podemos lograr esto?

El truco consiste en tener una dirección configurable en su pantalla. Esta unidad tiene una dirección configurable entre 0x78 y 0x7A. Simplemente desoldando la resistencia de 0 Ohmios de un lado y uniéndola al otro lado o simplemente colocando una soldadura global, podemos cambiar la dirección. Hablaremos de ello en profundidad cuando conectemos varias pantallas a un Arduino en la sección posterior de este tutorial.

En la imagen, estas pantallas se ven muy grandes. Pero, prácticamente hablando, son diminutos. Están hechos de píxeles OLED individuales de 128 x 32/64 y no requieren luz de fondo. Solo eche un vistazo a esto y vea lo pequeño que es. Aunque son pequeños, pueden ser de gran utilidad en cualquier proyecto electrónico.

Paso 6: biblioteca

Hay varias bibliotecas disponibles para controlar estos

muestra. En el pasado he usado la "biblioteca u8glib" pero encuentro la biblioteca AdaFruit muy fácil de entender y usar en nuestros proyectos. Entonces, voy a usar la biblioteca AdaFruit en este tutorial.

Para controlar la pantalla OLED, necesitará la biblioteca "adafruit_GFX.h" y la biblioteca "adafruit_SSD1306.h".

Hay dos formas de descargar e instalar la biblioteca en su IDE de Arduino.

Método 1

Vaya al "Administrador de bibliotecas" y busque "adafruit_SSD1306" y "adafruit_gfx"

Seleccione la última versión y presione el botón Instalar.

Una vez instaladas, puede utilizar estas bibliotecas en su programa.

Método 2

Estas dos bibliotecas también se pueden descargar desde github (necesita ambas):

Proporcionaré los enlaces en la descripción a continuación.

La biblioteca de visualización:

La biblioteca GFX:

Una vez descargado, copie la carpeta Adafruit_SSD1306-master del archivo comprimido descargado en la carpeta de bibliotecas de Arduino. Esta carpeta generalmente se encuentra en Documentos> Arduino> bibliotecas en sistemas Windows. En Linux, generalmente se encuentra en la carpeta de inicio> Arduino> bibliotecas. Finalmente, en la carpeta de la biblioteca Arduino, cambie el nombre de la carpeta Adafruit_SSD1306-master a Adafruit_SSD1306. Incluso si no cambia el nombre, está bien.

Paso 7:

Ahora, echemos un vistazo a "Adafruit_SSD1306.h"

expediente

Dos cosas que necesitamos saber en esta biblioteca:

1. Si desea usar la pantalla más pequeña, use el 128_32 predeterminado; de lo contrario, para la pantalla más grande, comente el 128_32 y descomente el 128_64

2. Si ha soldado la dirección 0x7A en la placa (de la que hablaremos más adelante), utilice la dirección 0x3D de 7 bits para las pantallas más grandes; de lo contrario, utilice la dirección 0x3C predeterminada. Para las pantallas más pequeñas, la dirección es 0x3C.

Paso 8: Cableado de OLED de 128 X 64/32

Comencemos conectando el NodeMCU a la pantalla.

Lo primero y más importante a tener en cuenta es que algunas de las pantallas pueden tener los pines de alimentación GND y VCC intercambiados. Verifique su pantalla para asegurarse de que sea la misma que la imagen. Si se intercambian los pines, asegúrese de cambiar las conexiones al Arduino o NodeMCU.

- Cableado OLED NodeMCU

OLED VCC - NodeMCU 3.3V

OLED GND - NodeMCU GND

OLED SCL - NodeMCU D1

OLED SDA - NodeMCU D2

- Cableado OLED Arduino Uno

OLED VCC - Arduino 5V

OLED GND - Arduino GND

OLED SCL - Arduino Uno A5

OLED SDA - Arduino Uno A4

- Cableado OLED Arduino MEGA 2560

OLED VCC - Arduino 5V

OLED GND - Arduino GND

OLED SCL - Arduino MEGA 2560 pin 21

OLED SDA - Arduino MEGA 2560 pin 20

Paso 9: Código

La biblioteca Adafruit viene con muy buenos ejemplos para ambos

Pantallas de 128x32 y 128x64.

La biblioteca se encuentra en Archivo> Ejemplos> Adafruit SSD1306> y luego el tipo de pantalla en el IDE de Arduino.

Vamos a utilizar el ejemplo de I2C de 128x32 y lo modificaremos para que funcione con pantallas de 128x64 y 128x32 primero conectándolo a un Arduino y luego a una placa NodeMCU.

El código comienza por incluir ambas bibliotecas de Adafruit. En este tutorial voy a enfatizar solo aquellas partes del código que son necesarias para que carguemos tanto en tableros como en pantallas. Si desea saber más sobre el código, deje un comentario en mi blog o en la sección de comentarios a continuación y me esforzaré en comunicarme con usted.

- Primero vamos a cargar el código en un Arduino Nano conectado a una pantalla de 128x32.

Podemos usar el código tal cual sin modificaciones.

128x32 usa la dirección 0x3C, por lo que este bit se ve bien aquí, verifiquemos la biblioteca de encabezados, sí, también usa la dirección 0x3C y el tipo de pantalla es 128x32.

- Ahora conectemos la pantalla de 128x64. Como sabemos, utiliza la dirección 0x3C de forma predeterminada, por lo que no necesitamos actualizar la dirección ni en el código ni en la biblioteca.

Solo necesitamos comentar el 128_32 y descomentar el 128_64 en la biblioteca de encabezado y cambiar LCDHEIGHT a 64 en nuestro código.

- Ahora, para ejecutar el mismo código en un NodeMCU, necesitamos cambiar una línea más en nuestro código.

El resto del código "#define OLED_RESET 4"> "#define OLED_RESET LED_BUILTIN" es igual que Arduino

Prácticamente para mostrar cualquier cosa, primero necesitamos borrar la pantalla anterior usando

display.clearDisplay (); // Limpiar el búfer

Luego dibuja el objeto

testdrawline (); // Dibuja una línea

Muéstralo en el hardware

display.display (); // ¡Hazlos visibles en el hardware de la pantalla!

Espere un tiempo antes de mostrar el siguiente elemento.

retraso (2000); // Espera 2 segundos

En este ejemplo, mostramos algunos elementos como texto, líneas, círculos, texto desplazable, triángulos y más. Adelante, use su imaginación y muestre lo que quiera en estas pequeñas pantallas.

Paso 10: personalización de texto y adición de imágenes

A veces, su código necesita mostrar fuentes personalizadas y

imágenes. Si eres muy bueno en el mapeo de bits, solo necesitas crear matrices de bytes encendiendo o apagando los pequeños LED de la pantalla para crear fuentes e imágenes personalizadas.

Sin embargo, no soy muy bueno haciendo estas asignaciones y no quiero pasar horas creando tablas de mapas de bits.

¿Entonces cuales son mis opciones? Generalmente uso dos sitios web para generar fuentes e imágenes personalizadas. Los enlaces se proporcionan en la descripción a continuación.

Fuentes personalizadas

Vaya al sitio web del convertidor de fuentes, seleccione la familia de fuentes, el estilo, el tamaño y la versión de la biblioteca como "Fuente Adafruit GFX" y luego presione el botón "Crear". En el lado derecho de esta página, puede ver cómo se verá su fuente en la pantalla real.

Según su selección, la página web genera el archivo de encabezado de fuentes. Cree un archivo llamado "modified_font.h" en la misma carpeta donde está su código y copie y guarde el código generado en él. Luego, solo necesita incluir el archivo de encabezado en su código para usar la fuente personalizada.

#include "modified_font.h"

Luego, solo necesita configurar la fuente antes de mostrar el texto para aplicarle la fuente personalizada.

display.setFont (& Your_Fonts_Name);

Puede obtener el nombre de la fuente del archivo de encabezado que acaba de agregar a su proyecto. Eso es, fácil.

La memoria siempre es una preocupación cuando se utilizan fuentes personalizadas, por lo tanto, siempre considere los bytes que consumirá la memoria. Solo recuerde que Arduino UNO tiene solo 32K de memoria.

Imágenes personalizadas

Para mostrar una imagen de mapa de bits en la pantalla, primero debe crear una imagen de tamaño 128 x 64/32.

Estoy usando el viejo "MS Paint" para crear una imagen de mapa de bits de 128 x 64 que luego subiré a este sitio web de conversión de imágenes. El sitio web convierte imágenes en cadenas de bytes, que se pueden utilizar con pantallas Arduino y OLED.

Empiece subiendo la imagen al sitio web. Luego marque la casilla de verificación "Invertir colores de imagen" y cambie el "Formato de código de salida" a "Código Arduino", luego seleccione la orientación y presione el botón "Generar código" para generar la matriz de bytes. La sección "Vista previa" le muestra cómo se verá su imagen en la pantalla real.

He incluido el código junto con este tutorial que puede usar para mostrar sus imágenes. Solo necesita reemplazar la matriz en mi código con la que acaba de generar y luego cargarla en su Arduino.

Paso 11: Conexión de 2 pantallas

Conectar dos pantallas de 128 x 64 a su proyecto es fácil.

Solo necesita desoldar la resistencia 0Ohm de la dirección 0x78 y ponerla en 0x7A y luego usar la dirección 0x3D en su código en lugar del 0x3C predeterminado.

Debe preguntarse por qué estamos usando la dirección 0x3C y 0x3D y no el 0x78 y 0x7A reales. Arduino acepta direcciones de 7 bits y no direcciones de hardware de 8 bits. Entonces, primero necesitamos convertir la dirección de 8 bits a binaria y luego cortar el bit menos significativo para obtener los 7 bits. Luego, convierta los 7 bits a HEX para obtener las direcciones 0x3C o 0x3D que ingresa en su código.

Primero, inicialice la pantalla dándole un nombre único:

Adafruit_SSD1306 display1 (OLED_REST);

Adafruit_SSD1306 display2 (OLED_REST);

Luego, en su código, use la pantalla 1 y la pantalla 2 para llamar a las declaraciones de inicio con las direcciones de dispositivo en ellas:

display1.begin (SSD1306_SWITCHCAPVCC, 0x3C); // mostrar 1 dirección op 0x3C

display2.begin (SSD1306_SWITCHCAPVCC, 0x3D); // mostrar 2 direcciones op 0x3D

Eso es todo, ahora puede seguir adelante y hacer lo que quiera usando la Pantalla 1 o la Pantalla 2 en el resto de su código. He proporcionado un ejemplo con este tutorial.

El cableado es exactamente el mismo que hemos hecho antes, prácticamente solo necesita agregar otra pantalla a los mismos pines I2C de Arduino o NodeMCU. Según las direcciones, la MCU envía los datos a la línea de datos I2C.

Paso 12: Conexión de más de 2 pantallas

Ahora, ¿qué pasa si desea conectar más de 2 pantallas?

Arduino tiene un número limitado de pines y, por lo tanto, no puede tener más de una cierta cantidad de escudos adjuntos. Además, solo tiene un par de buses I2C.

Entonces, ¿cómo podemos conectar más de 2 pantallas I2C a un Arduino? El truco consiste en utilizar un multiplexor TCA9548.

TCA9548 permite que un solo microcontrolador se comunique con hasta '64 sensores ', todos con la misma o diferente dirección I2C asignando un canal único a cada subbus esclavo de sensor.

Cuando hablamos de enviar datos a través de 2 cables a varios dispositivos, entonces necesitamos una forma de abordarlos. Es lo mismo que el cartero que viene por una sola carretera y deja los paquetes de correo en diferentes casas porque tienen diferentes direcciones escritas en ellos.

El multiplexor se conecta a las líneas 3V3, GND, SDA y SCL del microcontrolador. Los sensores esclavos están conectados a uno de los ocho puertos esclavos SCL / SDA en la placa. Los canales se seleccionan enviando al TCA9548A su dirección I2C (0x70 {predeterminado} - 0x77) seguida del número de canal (0b00000001 - 0b10000000). Podría tener como máximo 8 de estos multiplexores conectados entre sí en direcciones 0x70-0x77 para controlar 64 de las mismas partes direccionadas I2C. Al conectar los tres bits de dirección A0, A1 y A2 al VIN, puede obtener una combinación diferente de las direcciones. Explicaré esto en profundidad en mi próximo tutorial sobre la placa de conexión TCA9548A. Por ahora, conectemos 8 OLED a esta placa y echemos un vistazo rápido al código.

Conexión:

VIN a 5 V (o 3,3 V)

GND a tierra

Reloj SCL a I2C

Datos SDA a I2C

Luego conecte los sensores a VIN, GND y use uno de los buses multiplexados SCn / SDn

Ahora, Int el código comencemos por incluir la biblioteca "Wire" y definiendo la dirección de los multiplexores.

#include "Wire.h"

#incluir

#define MUX_Address 0x70 // TCA9548A Dirección de codificadores

Luego, debemos seleccionar el puerto al que queremos comunicarnos y enviar los datos usando esta función:

void tcaselect (uint8_t i) {

si (i> 7) return;

Wire.beginTransmission (MUX_Address);

Wire.write (1 << i);

Wire.endTransmission ();

}

A continuación, inicializaremos la pantalla en la sección de configuración llamando a "u8g.begin ();" para cada pantalla adjunta al MUX "tcaselect (i)";

Una vez inicializados, podemos hacer lo que queramos simplemente llamando a la función "tcaselect (i);" donde "i" es el valor del bus multiplexado y luego envía los datos y el reloj en consecuencia.

Paso 13: ventajas y desventajas

La imagen de un OLED es hermosa. Sin embargo, los OLED también tienen

desventajas. Debido a que las pantallas OLED contienen material orgánico, su vida útil es más corta que la de las pantallas LCD. Además, muchas pantallas OLED se queman después de mostrar la misma imagen durante mucho tiempo. Después de un quemado, la imagen permanece en la pantalla incluso después de mostrar otra imagen. Así que asegúrese de seguir actualizando la pantalla cada pocos segundos. El agua puede dañar instantáneamente los materiales orgánicos de estas pantallas.

Ventajas

Sin necesidad de luz de fondo

Las pantallas son muy delgadas y livianas

Bajo consumo de energía

Los ángulos de visión son más anchos que los LCD

El brillo y el contraste son geniales

Alta velocidad y tiempo de respuesta bajo.

Color negro intenso

Desventajas

Tecnología costosa

Ciclo de vida corto

Los OLED son más propensos a quemarse

Daños por agua

Paso 14: Errores comunes

Para concluir el tutorial, hablemos de algunos errores comunes.

que la gente hace al usar estas pantallas:

- Siempre verifique tres veces los pines antes de usarlo en su proyecto

- Elija la dirección de biblioteca correcta en el archivo de encabezado y en su código

#define SSD1306_I2C_ADDRESS 0x3C // en Adafruit_SSD1306.h

y

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); // en tu código

Si la dirección es incorrecta, el OLED no mostrará nada

- El tamaño de la pantalla debe cambiarse en el controlador antes de que pueda usarse. Si no se cambia, aparecerá un mensaje de error al intentar verificar el código.

#error ("Altura incorrecta, corrija Adafruit_SSD1306.h!");

- Si usa NodeMCU, asegúrese de reemplazar OLED_RESET de 4 a LED_BUILTIN

#define OLED_RESET LED_BUILTIN

Tengo gente de escena que hace todo tipo de cosas con esta pantalla OLED. Algunos incluso han hecho videojuegos y todo. Realmente no estoy interesado en hacer un videojuego usando esta pequeña pantalla. Sin embargo, ahora te dejo para que explores tu imaginación y salgas con ideas asombrosas.

Paso 15: Enlaces

- Blog:

- Agregar imagen:

- Texto personalizado:

- Biblioteca de visualización de Adafruit:

- Biblioteca Adafruit GFX:

- biblioteca u8glib: https://code.google.com/archive/p/u8glib/ o

Si desea usar la pantalla más pequeña, use el 128_32 predeterminado; de lo contrario, para la pantalla más grande, comente el 128_32 y descomente el 128X64 NO_ACK en su código (solo descomente el tipo de pantalla que está usando) (las fuentes están en la biblioteca de fuentes)