¿Estás listo para llevar tus proyectos con Arduino al siguiente nivel? En este artículo te brindaremos todas las instrucciones que necesitas para controlar una pantalla OLED a través de I2C. ¡Prepárate para aprender y sorprender con tus creaciones tecnológicas!
Este artículo muestra cómo utilizar la pantalla OLED I2C SSD1306 de 0,96 pulgadas con Arduino. Le mostraremos algunas características de la pantalla OLED, cómo conectarla a la placa Arduino y cómo escribir texto, dibujar formas y mostrar imágenes de mapa de bits. Finalmente, crearemos un ejemplo de proyecto que muestre los valores de temperatura y humedad.
El diodo orgánico emisor de luz La pantalla (OLED) que usaremos en este tutorial es el modelo SSD1306: una pantalla monocolor de 0,96 pulgadas y 128 x 64 píxeles, como se muestra en la imagen a continuación.
La pantalla OLED no requiere retroiluminación, lo que crea un contraste muy agradable en ambientes oscuros. Además, los píxeles sólo utilizan energía cuando están encendidos, por lo que la pantalla OLED utiliza menos energía en comparación con otras pantallas.
El modelo que estamos usando aquí tiene solo cuatro pines y se comunica con Arduino mediante el protocolo de comunicación I2C. Hay modelos que están equipados con un pin RESET adicional. También hay otras pantallas OLED que se comunican mediante comunicación SPI.
Configuración de pines
Dado que la pantalla OLED utiliza el protocolo de comunicación I2C, el cableado es muy sencillo. Todo lo que necesita hacer es conectarse a los pines Arduino Uno I2C como se muestra en la siguiente tabla.
Bolígrafo
Cableado con Arduino Uno
vino
5V
Dimensiones
Dimensiones
SCL
A5
ASD
A4
Si está utilizando otra placa Arduino, asegúrese de verificar los pines I2C correctos:
Nano: SDA (A4);
MEGA: ASD (20);
Leonardo: ASD (20); SCL (21);
Bibliotecas
Para controlar la pantalla OLED necesitas adafruit_SSD1306.h y eso adafruit_GFX.h Bibliotecas. Siga las siguientes instrucciones para instalar estas bibliotecas.
1. Abra su IDE de Arduino y vaya a Bosquejo > incluir biblioteca > Administrar bibliotecas. El administrador de la biblioteca debería abrirse.
2. Ingrese «SSD1306”en el cuadro de búsqueda e instale la biblioteca SSD1306 de Adafruit.
3. Después de instalar la biblioteca SSD1306 de Adafruit, escriba «gráfico“ en el campo de búsqueda e instale la biblioteca.
4. Reinicie su IDE de Arduino después de instalar las bibliotecas.
Consejos para escribir texto con estas bibliotecas
A continuación se presentan algunas funciones que le ayudarán a utilizar la biblioteca de pantallas OLED para escribir texto o dibujar gráficos simples.
Pantalla.ClearDisplay() – todos los píxeles están apagados
display.drawPixel(x,y,color) – mostrar un píxel en las coordenadas x,y
Display.SetTextSize(s) – Establezca el tamaño de fuente, se admiten los tamaños del 1 al 8
Mostrar.setCursor(x,y) – Establecer las coordenadas para comenzar a escribir texto.
display.print(«Mensaje») – imprime los caracteres en la posición x,y
Pantalla.Pantalla() – llame a este método para que los cambios surtan efecto
Probando la pantalla OLED
Después de conectar la pantalla OLED al Arduino e instalar todas las bibliotecas necesarias, puede verificar si todo funciona correctamente usando un ejemplo de la biblioteca.
Vaya a su IDE de Arduino archivo > Ejemplos > Adafruta SSD1306 y seleccione la pantalla de ejemplo que está utilizando.
Debería cargarse el siguiente código:
/*********
Complete project details at https://randomnerdtutorials.com
This is an example for our Monochrome OLEDs based on SSD1306 drivers. Pick one up today in the adafruit shop! ------> http://www.adafruit.com/category/63_98
This example is for a 128x32 pixel display using I2C to communicate 3 pins are required to interface (two I2C and one reset).
Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit!
Written by Limor Fried/Ladyada for Adafruit Industries, with contributions from the open source community. BSD license, check license.txt for more information All text above, and the splash screen below must be included in any redistribution.
*********/
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
#define NUMFLAKES 10 // Number of snowflakes in the animation example
#define LOGO_HEIGHT 16
#define LOGO_WIDTH 16
static const unsigned char PROGMEM logo_bmp[] =
{ B00000000, B11000000,
B00000001, B11000000,
B00000001, B11000000,
B00000011, B11100000,
B11110011, B11100000,
B11111110, B11111000,
B01111110, B11111111,
B00110011, B10011111,
B00011111, B11111100,
B00001101, B01110000,
B00011011, B10100000,
B00111111, B11100000,
B00111111, B11110000,
B01111100, B11110000,
B01110000, B01110000,
B00000000, B00110000 };
void setup() {
Serial.begin(115200);
// SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println(F("SSD1306 allocation failed"));
for(;;); // Don't proceed, loop forever
}
// Show initial display buffer contents on the screen --
// the library initializes this with an Adafruit splash screen.
display.display();
delay(2000); // Pause for 2 seconds
// Clear the buffer
display.clearDisplay();
// Draw a single pixel in white
display.drawPixel(10, 10, WHITE);
// Show the display buffer on the screen. You MUST call display() after
// drawing commands to make them visible on screen!
display.display();
delay(2000);
// display.display() is NOT necessary after every single drawing command,
// unless that's what you want...rather, you can batch up a bunch of
// drawing operations and then update the screen all at once by calling
// display.display(). These examples demonstrate both approaches...
testdrawline(); // Draw many lines
testdrawrect(); // Draw rectangles (outlines)
testfillrect(); // Draw rectangles (filled)
testdrawcircle(); // Draw circles (outlines)
testfillcircle(); // Draw circles (filled)
testdrawroundrect(); // Draw rounded rectangles (outlines)
testfillroundrect(); // Draw rounded rectangles (filled)
testdrawtriangle(); // Draw triangles (outlines)
testfilltriangle(); // Draw triangles (filled)
testdrawchar(); // Draw characters of the default font
testdrawstyles(); // Draw 'stylized' characters
testscrolltext(); // Draw scrolling text
testdrawbitmap(); // Draw a small bitmap image
// Invert and restore display, pausing in-between
display.invertDisplay(true);
delay(1000);
display.invertDisplay(false);
delay(1000);
testanimate(logo_bmp, LOGO_WIDTH, LOGO_HEIGHT); // Animate bitmaps
}
void loop() {
}
void testdrawline() {
int16_t i;
display.clearDisplay(); // Clear display buffer
for(i=0; i<display.width(); i+=4) {
display.drawLine(0, 0, i, display.height()-1, WHITE);
display.display(); // Update screen with each newly-drawn line
delay(1);
}
for(i=0; i<display.height(); i+=4) {
display.drawLine(0, 0, display.width()-1, i, WHITE);
display.display();
delay(1);
}
delay(250);
display.clearDisplay();
for(i=0; i<display.width(); i+=4) {
display.drawLine(0, display.height()-1, i, 0, WHITE);
display.display();
delay(1);
}
for(i=display.height()-1; i>=0; i-=4) {
display.drawLine(0, display.height()-1, display.width()-1, i, WHITE);
display.display();
delay(1);
}
delay(250);
display.clearDisplay();
for(i=display.width()-1; i>=0; i-=4) {
display.drawLine(display.width()-1, display.height()-1, i, 0, WHITE);
display.display();
delay(1);
}
for(i=display.height()-1; i>=0; i-=4) {
display.drawLine(display.width()-1, display.height()-1, 0, i, WHITE);
display.display();
delay(1);
}
delay(250);
display.clearDisplay();
for(i=0; i<display.height(); i+=4) {
display.drawLine(display.width()-1, 0, 0, i, WHITE);
display.display();
delay(1);
}
for(i=0; i<display.width(); i+=4) {
display.drawLine(display.width()-1, 0, i, display.height()-1, WHITE);
display.display();
delay(1);
}
delay(2000); // Pause for 2 seconds
}
void testdrawrect(void) {
display.clearDisplay();
for(int16_t i=0; i<display.height()/2; i+=2) {
display.drawRect(i, i, display.width()-2*i, display.height()-2*i, WHITE);
display.display(); // Update screen with each newly-drawn rectangle
delay(1);
}
delay(2000);
}
void testfillrect(void) {
display.clearDisplay();
for(int16_t i=0; i<display.height()/2; i+=3) {
// The INVERSE color is used so rectangles alternate white/black
display.fillRect(i, i, display.width()-i*2, display.height()-i*2, INVERSE);
display.display(); // Update screen with each newly-drawn rectangle
delay(1);
}
delay(2000);
}
void testdrawcircle(void) {
display.clearDisplay();
for(int16_t i=0; i<max(display.width(),display.height())/2; i+=2) {
display.drawCircle(display.width()/2, display.height()/2, i, WHITE);
display.display();
delay(1);
}
delay(2000);
}
void testfillcircle(void) {
display.clearDisplay();
for(int16_t i=max(display.width(),display.height())/2; i>0; i-=3) {
// The INVERSE color is used so circles alternate white/black
display.fillCircle(display.width() / 2, display.height() / 2, i, INVERSE);
display.display(); // Update screen with each newly-drawn circle
delay(1);
}
delay(2000);
}
void testdrawroundrect(void) {
display.clearDisplay();
for(int16_t i=0; i<display.height()/2-2; i+=2) {
display.drawRoundRect(i, i, display.width()-2*i, display.height()-2*i,
display.height()/4, WHITE);
display.display();
delay(1);
}
delay(2000);
}
void testfillroundrect(void) {
display.clearDisplay();
for(int16_t i=0; i<display.height()/2-2; i+=2) {
// The INVERSE color is used so round-rects alternate white/black
display.fillRoundRect(i, i, display.width()-2*i, display.height()-2*i,
display.height()/4, INVERSE);
display.display();
delay(1);
}
delay(2000);
}
void testdrawtriangle(void) {
display.clearDisplay();
for(int16_t i=0; i<max(display.width(),display.height())/2; i+=5) {
display.drawTriangle(
display.width()/2 , display.height()/2-i,
display.width()/2-i, display.height()/2+i,
display.width()/2+i, display.height()/2+i, WHITE);
display.display();
delay(1);
}
delay(2000);
}
void testfilltriangle(void) {
display.clearDisplay();
for(int16_t i=max(display.width(),display.height())/2; i>0; i-=5) {
// The INVERSE color is used so triangles alternate white/black
display.fillTriangle(
display.width()/2 , display.height()/2-i,
display.width()/2-i, display.height()/2+i,
display.width()/2+i, display.height()/2+i, INVERSE);
display.display();
delay(1);
}
delay(2000);
}
void testdrawchar(void) {
display.clearDisplay();
display.setTextSize(1); // Normal 1:1 pixel scale
display.setTextColor(WHITE); // Draw white text
display.setCursor(0, 0); // Start at top-left corner
display.cp437(true); // Use full 256 char 'Code Page 437' font
// Not all the characters will fit on the display. This is normal.
// Library will draw what it can and the rest will be clipped.
for(int16_t i=0; i<256; i++) {
if(i == 'n') display.write(' ');
else display.write(i);
}
display.display();
delay(2000);
}
void testdrawstyles(void) {
display.clearDisplay();
display.setTextSize(1); // Normal 1:1 pixel scale
display.setTextColor(WHITE); // Draw white text
display.setCursor(0,0); // Start at top-left corner
display.println(F("Hello, world!"));
display.setTextColor(BLACK, WHITE); // Draw 'inverse' text
display.println(3.141592);
display.setTextSize(2); // Draw 2X-scale text
display.setTextColor(WHITE);
display.print(F("0x")); display.println(0xDEADBEEF, HEX);
display.display();
delay(2000);
}
void testscrolltext(void) {
display.clearDisplay();
display.setTextSize(2); // Draw 2X-scale text
display.setTextColor(WHITE);
display.setCursor(10, 0);
display.println(F("scroll"));
display.display(); // Show initial text
delay(100);
// Scroll in various directions, pausing in-between:
display.startscrollright(0x00, 0x0F);
delay(2000);
display.stopscroll();
delay(1000);
display.startscrollleft(0x00, 0x0F);
delay(2000);
display.stopscroll();
delay(1000);
display.startscrolldiagright(0x00, 0x07);
delay(2000);
display.startscrolldiagleft(0x00, 0x07);
delay(2000);
display.stopscroll();
delay(1000);
}
void testdrawbitmap(void) {
display.clearDisplay();
display.drawBitmap(
(display.width() - LOGO_WIDTH ) / 2,
(display.height() - LOGO_HEIGHT) / 2,
logo_bmp, LOGO_WIDTH, LOGO_HEIGHT, 1);
display.display();
delay(1000);
}
#define XPOS 0 // Indexes into the 'icons' array in function below
#define YPOS 1
#define DELTAY 2
void testanimate(const uint8_t *bitmap, uint8_t w, uint8_t h) {
int8_t f, icons[NUMFLAKES][3];
// Initialize 'snowflake' positions
for(f=0; f< NUMFLAKES; f++) {
icons[f][XPOS] = random(1 - LOGO_WIDTH, display.width());
icons[f][YPOS] = -LOGO_HEIGHT;
icons[f][DELTAY] = random(1, 6);
Serial.print(F("x: "));
Serial.print(icons[f][XPOS], DEC);
Serial.print(F(" y: "));
Serial.print(icons[f][YPOS], DEC);
Serial.print(F(" dy: "));
Serial.println(icons[f][DELTAY], DEC);
}
for(;;) { // Loop forever...
display.clearDisplay(); // Clear the display buffer
// Draw each snowflake:
for(f=0; f< NUMFLAKES; f++) {
display.drawBitmap(icons[f][XPOS], icons[f][YPOS], bitmap, w, h, WHITE);
}
display.display(); // Show the display buffer on the screen
delay(200); // Pause for 1/10 second
// Then update coordinates of each flake...
for(f=0; f< NUMFLAKES; f++) {
icons[f][YPOS] += icons[f][DELTAY];
// If snowflake is off the bottom of the screen...
if (icons[f][YPOS] >= display.height()) {
// Reinitialize to a random position, just off the top
icons[f][XPOS] = random(1 - LOGO_WIDTH, display.width());
icons[f][YPOS] = -LOGO_HEIGHT;
icons[f][DELTAY] = random(1, 6);
}
}
}
}
Sube el código a tu placa Arduino. No olvides utilizar la placa y el puerto COM correctos. Herramientas Menú.
Deberías obtener varias animaciones diferentes en la pantalla OLED, como se muestra en el breve vídeo a continuación.
Si su pantalla OLED no muestra nada:
Compruebe si la pantalla OLED está conectada correctamente al Arduino.
Verifique dos veces la dirección I2C de la pantalla OLED: cuando la pantalla OLED está conectada al Arduino, sube este código y verifique la dirección I2C en el monitor serial
Si es necesario, debe ajustar la dirección OLED en la siguiente línea. En nuestro caso la dirección es 0x3C.
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Escribir texto – Pantalla OLED
La biblioteca Adafruit para la pantalla OLED contiene varias funciones para escribir texto. En esta sección, aprenderá a escribir texto y desplazarse utilizando las funciones de la biblioteca.
«¡Hola mundo!»
El siguiente boceto muestra ¡Hola Mundo! Mensaje en la pantalla OLED.
Después de cargar el código, obtendrás lo siguiente en tu OLED:
Echemos un vistazo rápido a cómo funciona el código.
Importando bibliotecas
Primero necesitas importar las bibliotecas necesarias. cable Biblioteca para usar I2C y las bibliotecas Adafruit para escribir en la pantalla: Adafruit_GFX Y Adafruit_SSD1306.
Luego defina el ancho y el alto de su pantalla OLED. En este ejemplo utilizamos una pantalla OLED de 128×64. Si usas otros tamaños, puedes usarlos en el ANCHO DE PANTALLAY ALTURA DE LA PANTALLA Variables.
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
Luego inicialice un objeto de visualización con el ancho y alto previamente definidos utilizando el protocolo de comunicación I2C (&Cable).
El parámetro (-1) significa que su pantalla OLED no tiene un pin RESET. Si su pantalla OLED tiene un pin RESET, debe estar conectado a un GPIO. En este caso deberás pasar el número GPIO como parámetro.
En el configuración()Inicialice el monitor en serie con una velocidad de baudios de 115200 para fines de depuración.
Serial.begin(115200);
Inicialice la pantalla OLED con el comenzar() Método de la siguiente manera:
Agregue un retraso de dos segundos después de que la pantalla se inicialice para darle tiempo suficiente a la pantalla OLED para inicializarse antes de que se escriba el texto:
delay(2000);
Diseñe la pantalla con claridad, establezca el tamaño y el color de la fuente y escriba texto
Después de inicializar la pantalla, borre el búfer de pantalla con el Borrar pantalla() Método:
display.clearDisplay();
Antes de escribir texto, debe configurar el tamaño y el color del texto y determinar dónde aparecerá el texto en la pantalla OLED.
Establezca el tamaño de fuente con el establecerTamañoTexto() Método:
display.setTextSize(1);
Establezca el color de fuente con el establecerColorTexto() Método:
display.setTextColor(WHITE);
BLANCO establece fuente blanca y fondo negro.
Defina la posición donde el texto comienza con el establecerCursor(x,y) Método. En este caso configuramos el texto para que comience en las coordenadas (0,10).
display.setCursor(0,10);
Finalmente puedes editar el texto con el prensa() Método de la siguiente manera:
display.println("Hello, world!");
Entonces llámalo Anuncio publicitario() Método para mostrar realmente el texto en la pantalla.
display.display();
Texto en ejecución
La biblioteca Adafruit OLED proporciona métodos útiles para desplazar texto fácilmente.
InicioDesplazamientoDerecha(0x00, 0x0F): desplaza el texto de izquierda a derecha
Enlaces de inicio de desplazamiento (0x00, 0x0F): desplaza el texto de derecha a izquierda
StartScrolldiagright (0x00, 0x07): desplaza el texto desde la esquina inferior izquierda hasta la esquina superior derecha
StartScrolldiagleft(0x00, 0x07): desplaza el texto desde la esquina inferior derecha hasta la esquina superior izquierda
El texto se desplaza como se muestra en el breve vídeo a continuación.
Utilice otras fuentes: pantalla OLED
La biblioteca Adafruit GFX nos permite utilizar algunas fuentes alternativas además de las fuentes integradas. Puedes elegir entre Serif, Sans y Mono. Cada fuente está disponible en negrita, cursiva y en diferentes tamaños.
Los tamaños están determinados por la fuente respectiva. establecerTamañoTexto() El método no funciona con estas fuentes. Las fuentes están disponibles en tamaños de 9, 12, 18 y 24 puntos y también contienen caracteres de 7 bits (códigos ASCII) (denominados 7b en el nombre de la fuente).
Puede elegir entre la siguiente selección de fuentes:
Las fuentes de 9 y 12 puntos funcionan mejor con la pantalla OLED.
Para utilizar una de estas fuentes, primero debes insertarla en tu boceto, por ejemplo:
#include <Fonts/FreeSerif12pt7b.h>
A continuación sólo tienes que hacer lo establecerFuente() Método y pasa la fuente especificada como argumento:
display.setFont(&FreeSerif12pt7b);
Después de especificar la fuente, todos los métodos de escritura de texto utilizan esta fuente. Para volver a utilizar la fuente original, sólo necesita utilizar el establecerFuente() Método sin argumentos:
Ahora su pantalla imprimirá el mensaje «¡Hola mundo!» en la fuente FreeSerif.
Dibuja formas en la pantalla OLED
La biblioteca Adafruit OLED proporciona métodos útiles para dibujar píxeles, líneas y formas. Echemos un vistazo rápido a estos métodos.
dibujar un píxel
Para dibujar un píxel en la pantalla OLED, puede utilizar el dibujarPixel(x, y, color) Método que acepta como argumentos las coordenadas x e y donde aparece el píxel, así como el color. Ejemplo:
display.drawPixel(64, 32, WHITE);
Dibuja una línea
Utilizar el dibujarLínea(x1, y1, x2, y2, color) Método de creación de una línea. Las coordenadas (x1, y1) indican el comienzo de la línea y las coordenadas (x2, y2) indican dónde termina la línea. Ejemplo:
display.drawLine(0, 0, 127, 20, WHITE);
dibujar un rectángulo
El drawRect(x, y, ancho, alto, color) proporciona una manera fácil de dibujar un rectángulo. Las coordenadas (x,y) indican la esquina superior izquierda del rectángulo. Luego debe especificar el ancho, alto y color:
display.drawRect(10, 10, 50, 30, WHITE);
Puedes utilizar el… fillRect(x, y, ancho, alto, color) para dibujar un rectángulo relleno. Este método acepta los mismos argumentos que dibujarRect().
La biblioteca también proporciona métodos para mostrar rectángulos con esquinas redondeadas: dibujarRoundRect() Y llenarRoundRect(). Estos métodos aceptan los mismos argumentos que los métodos anteriores más el radio de la esquina. Ejemplo:
display.drawRoundRect(10, 10, 30, 50, 2, WHITE);
O un rectángulo redondo relleno:
display.fillRoundRect(10, 10, 30, 50, 2, WHITE);
Dibuja un circulo
Para dibujar un círculo, use el dibujarCírculo(x, y, radio, color) Método. Las coordenadas (x,y) indican el centro del círculo. También debes pasar el radio como argumento. Ejemplo:
display.drawCircle(64, 32, 10, WHITE);
De la misma manera, para construir un círculo relleno, use el círculo de relleno() Método con los mismos argumentos:
display.fillCircle(64, 32, 10, WHITE);
dibuja un triangulo
Utilizar el dibujarTriángulo(x1, y1, x2, y2, x3, y3, color) Método de creación de un triángulo. Este método acepta como argumentos las coordenadas de cada esquina y el color.
La biblioteca proporciona un método adicional que puede utilizar con formas o texto: el pantalla invertida() Método. Consistir VERDADERO como argumento para invertir los colores de la pantalla o INCORRECTO para restaurar los colores originales.
Si después de definir el triángulo llamas al siguiente comando:
display.invertDisplay(true);
Obtienes un triángulo invertido como este:
Código: dibujar formas
Cargue el siguiente boceto que implementa cada fragmento de código cubierto anteriormente y recorre todas las formas.
Mostrar imágenes de mapa de bits en una pantalla OLED
Puede mostrar imágenes monocromáticas de mapa de bits de 128×64 en la pantalla OLED.
Primero, utilice un programa de edición de imágenes para cambiar el tamaño de una foto o imagen y guardarla como un mapa de bits monocromático. Si está utilizando una PC con Windows, puede usar Paint.
Luego use un convertidor de imagen a matriz C para convertir la imagen en una matriz. Tengo Convertidor de imágenes LCD.
Ejecute el programa y arranque con una nueva imagen. Ir a Imagen > Importar y seleccione la imagen de mapa de bits que creó anteriormente.
Ir a Opciones > Conversión y en el Preparar Seleccione las siguientes opciones:
Tipo: Monocromo, tramado de umbral
Dirección principal de escaneo: De arriba hacia abajo
Dirección de escaneo de línea: Adelante
Vaya a la pestaña Imagen y seleccione las siguientes opciones:
Dividir en líneas
Tamaño de bloque: 8 bits
Orden de bytes: pequeño endian
Luego haga clic DE ACUERDOFinalmente, ve al menú principal. archivo > ConvertirUn nuevo archivo con .C La extensión debe guardarse. Este archivo contiene la matriz C para la imagen. Abra el archivo con un editor de texto y copie la matriz.
Copie su matriz en el boceto. Luego, para mostrar la matriz, use el dibujar mapa de bits() Método que acepta los siguientes argumentos (x, y, matriz de imágenes, ancho de imagen, alto de imagen, rotación). Las coordenadas (x, y) definen dónde comenzará a mostrarse la imagen.
Copie el siguiente código para mostrar su imagen de mapa de bits en la pantalla OLED.
Después de cargar el código, aparecerá lo siguiente en la pantalla.
Muestra la temperatura y la humedad en la pantalla OLED con Arduino
En esta sección, crearemos un proyecto que muestra valores de temperatura y humedad en la pantalla OLED. Determinamos la temperatura y la humedad utilizando el Sensor de temperatura y humedad DHT11Si no estás familiarizado con el sensor DHT11, lee el siguiente artículo:
Instrucciones completas para el sensor de humedad y temperatura DHT11/DHT22 con Arduino
Piezas requeridas
Para completar este proyecto necesitará los siguientes componentes:
Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!
Esquema
Monte el circuito según el siguiente diagrama de circuito.
Nota: Si utiliza un módulo con un sensor DHT, normalmente sólo tiene tres pines. Los pines deben estar etiquetados para que sepas cómo conectarlos. Además, muchos de estos módulos ya tienen una resistencia pull-up interna, por lo que no es necesario agregar una al circuito.
Instalación de bibliotecas
Antes de continuar, asegúrese de tener el «adafruit_GFX.h» y eso «adafruit_SSD1306.h“Bibliotecas para controlar la pantalla OLED.
Este proyecto también requiere dos bibliotecas adicionales para leer el sensor DHT: el DHTbiblioteca y el Adafruit_Sensor Biblioteca. Siga los siguientes pasos para instalar estas bibliotecas.
1. Abra su IDE de Arduino y vaya a Bosquejo > incluir biblioteca > Administrar bibliotecas. El administrador de la biblioteca debería abrirse.
2. Buscar «DHT”en el cuadro de búsqueda e instale la biblioteca DHT de Adafruit.
3. Después de instalar la biblioteca DHT de Adafruit, escriba «Sensor unificado de Adafruit”en el campo de búsqueda. Desplácese hacia abajo para buscar e instalar la biblioteca.
Lea esta sección si desea aprender cómo funciona el código. De lo contrario, puede pasar directamente a la sección «Demostración».
Importando bibliotecas
El código comienza incluyendo las bibliotecas necesarias. cable, Adafruit_GFX Y Adafruit_SSD1306 se utilizan para conectarse a la pantalla OLED. El Adafruit_Sensor y eso DHT Las bibliotecas se utilizan para interactuar con los sensores DHT22 o DHT11.
El parámetro (-1) significa que su pantalla OLED no tiene un pin RESET. Si su pantalla OLED tiene un pin RESET, debe estar conectado a un GPIO. En este caso deberás pasar el número GPIO como parámetro.
Creando un objeto DHT
Luego defina el tipo de sensor DHT que está utilizando. Si utiliza un DHT11, no necesita cambiar ningún código. Si está utilizando un sensor diferente, simplemente descomente el sensor que está utilizando y comente los demás.
En este caso la dirección de la pantalla OLED utilizada es Versión:. Si esta dirección no funciona, puede ejecutar un escáner I2C para encontrar su dirección OLED. Puede El boceto del escáner I2C se puede encontrar aquí.
Agregue un retraso para darle tiempo a la pantalla para inicializarse y borrarse y establecer el color del texto en blanco:
En el Cinta() Aquí leemos el sensor y mostramos la temperatura y la humedad en la pantalla.
Obtenga lecturas de temperatura y humedad de DHT
La temperatura y la humedad están en el t Y h Variables. Leer la temperatura y la humedad es tan fácil como usar el leer temperatura() Y leerhumedad() métodos en el dht Objeto.
float t = dht.readTemperature();
float h = dht.readHumidity();
Si no podemos recuperar las medidas, aparecerá un mensaje de error:
if (isnan(h) || isnan
Serial.println("Failed to read from DHT sensor!");
}
Si recibe este mensaje de error, consulte nuestra guía de solución de problemas: Cómo solucionar el problema «Error en la lectura del sensor DHT».
Visualización de los valores del sensor en la pantalla OLED
Las siguientes líneas muestran la temperatura en la pantalla OLED.
Usamos eso establecerTamañoTexto() Método para definir el tamaño de fuente, el establecerCursor() determina dónde se debe mostrar el texto y el prensa() El método se utiliza para escribir algo en la pantalla.
Para imprimir la temperatura y la humedad, solo necesitas especificar sus variables prensa() Método de la siguiente manera:
display.print
La etiqueta "Temperatura" se muestra en el tamaño 1 y la medida real se muestra en el tamaño 2.
Para representar el símbolo º utilizamos el Página de códigos 437 Fuente. Para hacer esto debes cp437 A VERDADERO como sigue:
display.cp437(true);
Entonces usa eso escribir() Método para mostrar el carácter seleccionado. El símbolo º corresponde al carácter 167.
display.write(167);
También se sigue un enfoque similar al mostrar la humedad:
No olvides que tienes que llamar. Pantalla.Pantalla() al final para que puedas mostrar algo en el OLED.
display.display();
demostración
Después de cablear el circuito y cargar el código, la pantalla OLED muestra los valores de temperatura y humedad. Los valores del sensor se actualizan cada cinco segundos.
Solución de problemas
Si su sensor DHT no proporciona lecturas o recibe el mensaje "Error al leer el sensor DHT", consulte nuestra Guía de solución de problemas de DHT para ayudarle a resolver este problema.
Si ves el mensaje “Error en la asignación de SSD1306”Se produce un error o la pantalla OLED no muestra nada, puede deberse a uno de los siguientes problemas:
Dirección I2C incorrecta
La dirección I2C para la pantalla OLED que estamos usando es 0x3C. Sin embargo, su dirección puede ser diferente. Así que asegúrese de verificar la dirección I2C de su pantalla con uno Bosquejo del escáner I2C.
SDA y SCL no están conectados correctamente
Asegúrese de haber conectado correctamente los pines SDA y SCL de la pantalla OLED.
Envolver
La pantalla OLED ofrece una forma sencilla y económica de mostrar texto o gráficos utilizando un Arduino. Esperamos que estas instrucciones y el ejemplo del proyecto te hayan ayudado.
Si te gusta Arduino, asegúrate de consultar todos nuestros recursos de Arduino:
Mini curso de Arduino (gratis)
Proyectos Arduino paso a paso (curso)
Más de 60 proyectos y tutoriales de Arduino
Recursos electrónicos y libros electrónicos gratuitos
¡No te pierdas nuestros próximos tutoriales y proyectos! Asegúrese de suscribirse al blog de RNT.
gracias por leer
Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded
Write an SEO optimized article for a blog, with frequently asked questions. About the following topic Instrucciones para pantalla OLED I2C con Arduino
. Get inspired by the following content,
This article shows how to use the SSD1306 0.96 inch I2C OLED display with the Arduino. We’ll show you some features of the OLED display, how to connect it to the Arduino board, and how to write text, draw shapes and display bitmap images. Lastly, we’ll build a project example that displays temperature and humidity readings.
Introducing the 0.96 inch OLED display
The organic light-emitting diode (OLED) display that we’ll use in this tutorial is the SSD1306 model: a monocolor, 0.96-inch display with 128×64 pixels as shown in the following figure.
The OLED display doesn’t require backlight, which results in a very nice contrast in dark environments. Additionally, its pixels consume energy only when they are on, so the OLED display consumes less power when compared with other displays.
The model we’re using here has only four pins and communicates with the Arduino using I2C communication protocol. There are models that come with an extra RESET pin. There are also other OLED displays that communicate using SPI communication.
Pin wiring
Because the OLED display uses I2C communication protocol, wiring is very simple. You just need to connect to the Arduino Uno I2C pins as shown in the table below.
PinWiring to Arduino UnoVin5VGNDGNDSCLA5SDAA4
If you’re using a different Arduino board, make sure you check the correct I2C pins:
Nano: SDA (A4); SCL (A5);
MEGA: SDA (20); SCL (21);
Leonardo: SDA (20); SCL (21);
Libraries
To control the OLED display you need the adafruit_SSD1306.h and the adafruit_GFX.h libraries. Follow the next instructions to install those libraries.
1. Open your Arduino IDE and go to Sketch > Include Library > Manage Libraries. The Library Manager should open.
2. Type “SSD1306” in the search box and install the SSD1306 library from Adafruit.
3. After installing the SSD1306 library from Adafruit, type “GFX” in the search box and install the library.
4. After installing the libraries, restart your Arduino IDE.
Tips for writing text using these libraries
Here’s some functions that will help you handle the OLED display library to write text or draw simple graphics.
display.clearDisplay() – all pixels are off
display.drawPixel(x,y, color) – plot a pixel in the x,y coordinates
display.setTextSize(n) – set the font size, supports sizes from 1 to 8
display.setCursor(x,y) – set the coordinates to start writing text
display.print(“message”) – print the characters at location x,y
display.display() – call this method for the changes to make effect
Testing the OLED Display
After wiring the OLED display to the Arduino and installing all required libraries, you can use one example from the library to see if everything is working properly.
In your Arduino IDE, go to File > Examples > Adafruit SSD1306 and select the example for the display you’re using.
The following code should load:
/*********
Complete project details at https://randomnerdtutorials.com
This is an example for our Monochrome OLEDs based on SSD1306 drivers. Pick one up today in the adafruit shop! ------> http://www.adafruit.com/category/63_98
This example is for a 128x32 pixel display using I2C to communicate 3 pins are required to interface (two I2C and one reset).
Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit!
Written by Limor Fried/Ladyada for Adafruit Industries, with contributions from the open source community. BSD license, check license.txt for more information All text above, and the splash screen below must be included in any redistribution.
*********/
// Show initial display buffer contents on the screen --
// the library initializes this with an Adafruit splash screen.
display.display();
delay(2000); // Pause for 2 seconds
// Clear the buffer
display.clearDisplay();
// Draw a single pixel in white
display.drawPixel(10, 10, WHITE);
// Show the display buffer on the screen. You MUST call display() after
// drawing commands to make them visible on screen!
display.display();
delay(2000);
// display.display() is NOT necessary after every single drawing command,
// unless that's what you want...rather, you can batch up a bunch of
// drawing operations and then update the screen all at once by calling
// display.display(). These examples demonstrate both approaches...
for(int16_t i=0; i<display.height()/2; i+=2) {
display.drawRect(i, i, display.width()-2*i, display.height()-2*i, WHITE);
display.display(); // Update screen with each newly-drawn rectangle
delay(1);
}
delay(2000);
}
void testfillrect(void) {
display.clearDisplay();
for(int16_t i=0; i<display.height()/2; i+=3) {
// The INVERSE color is used so rectangles alternate white/black
display.fillRect(i, i, display.width()-i*2, display.height()-i*2, INVERSE);
display.display(); // Update screen with each newly-drawn rectangle
delay(1);
}
for(int16_t i=max(display.width(),display.height())/2; i>0; i-=3) {
// The INVERSE color is used so circles alternate white/black
display.fillCircle(display.width() / 2, display.height() / 2, i, INVERSE);
display.display(); // Update screen with each newly-drawn circle
delay(1);
}
for(int16_t i=0; i<display.height()/2-2; i+=2) {
// The INVERSE color is used so round-rects alternate white/black
display.fillRoundRect(i, i, display.width()-2*i, display.height()-2*i,
display.height()/4, INVERSE);
display.display();
delay(1);
}
for(int16_t i=max(display.width(),display.height())/2; i>0; i-=5) {
// The INVERSE color is used so triangles alternate white/black
display.fillTriangle(
display.width()/2 , display.height()/2-i,
display.width()/2-i, display.height()/2+i,
display.width()/2+i, display.height()/2+i, INVERSE);
display.display();
delay(1);
}
delay(2000);
}
void testdrawchar(void) {
display.clearDisplay();
display.setTextSize(1); // Normal 1:1 pixel scale
display.setTextColor(WHITE); // Draw white text
display.setCursor(0, 0); // Start at top-left corner
display.cp437(true); // Use full 256 char 'Code Page 437' font
// Not all the characters will fit on the display. This is normal.
// Library will draw what it can and the rest will be clipped.
for(int16_t i=0; i<256; i++) {
if(i == 'n') display.write(' ');
else display.write(i);
}
display.setTextSize(1); // Normal 1:1 pixel scale
display.setTextColor(WHITE); // Draw white text
display.setCursor(0,0); // Start at top-left corner
display.println(F("Hello, world!"));
display.setTextColor(BLACK, WHITE); // Draw 'inverse' text
display.println(3.141592);
display.setTextSize(2); // Draw 2X-scale text
display.setTextColor(WHITE);
display.print(F("0x")); display.println(0xDEADBEEF, HEX);
display.setTextSize(2); // Draw 2X-scale text
display.setTextColor(WHITE);
display.setCursor(10, 0);
display.println(F("scroll"));
display.display(); // Show initial text
delay(100);
display.display(); // Show the display buffer on the screen
delay(200); // Pause for 1/10 second
// Then update coordinates of each flake...
for(f=0; f< NUMFLAKES; f++) {
icons[f][YPOS] += icons[f][DELTAY];
// If snowflake is off the bottom of the screen...
if (icons[f][YPOS] >= display.height()) {
// Reinitialize to a random position, just off the top
icons[f][XPOS] = random(1 - LOGO_WIDTH, display.width());
icons[f][YPOS] = -LOGO_HEIGHT;
icons[f][DELTAY] = random(1, 6);
}
}
}
}
View raw code
If your OLED doesn’t have a RESET pin, you should set the OLED_RESET variable to -1 as shown below:
Upload the code to your Arduino board. Don’t forget to select the right board and COM port in the Tools menu.
You should get a series of different animations in the OLED as shown in the following short video.
If your OLED display is not showing anything:
Check that the OLED display is properly wired to the Arduino
Double-check the OLED display I2C address: with the OLED connected to the Arduino, upload this code and check the I2C address in the Serial Monitor
You should change the OLED address in the following line, if necessary. In our case, the address is 0x3C.
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Write Text – OLED Display
The Adafruit library for the OLED display comes with several functions to write text. In this section, you’ll learn how to write and scroll text using the library functions.
“Hello, world!” OLED Display
The following sketch displays Hello, world! message in the OLED display.
/*********
Rui Santos
Complete project details at https://randomnerdtutorials.com
*********/
After uploading the code, this is what you’ll get in your OLED:
Let’s take a quick look on how the code works.
Importing libraries
First, you need to import the necessary libraries. The Wire library to use I2C and the Adafruit libraries to write to the display: Adafruit_GFX and Adafruit_SSD1306.
Then, you define your OLED width and height. In this example, we’re using a 128×64 OLED display. If you’re using other sizes, you can change that in the SCREEN_WIDTH, and SCREEN_HEIGHT variables.
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
Then, initialize a display object with the width and height defined earlier with I2C communication protocol (&Wire).
The (-1) parameter means that your OLED display doesn’t have a RESET pin. If your OLED display does have a RESET pin, it should be connected to a GPIO. In that case, you should pass the GPIO number as a parameter.
In the setup(), initialize the Serial Monitor at a baud raute of 115200 for debugging purposes.
Serial.begin(115200);
Initialize the OLED display with the begin() method as follows:
The text scrolls as shown in the following short video.
Using Other Fonts – OLED Display
The Adafruit GFX library allows us to use some alternate fonts besides the built-in fonts. It allows you to chose between Serif, Sans, and Mono. Each font is available in bold, italic and in different sizes.
The sizes are set by the actual font. So, the setTextSize() method doesn’t work with these fonts. The fonts are available in 9, 12, 18 and 24 point sizes and also contain 7-bit characters (ASCII codes) (described as 7b in the font name).
The fonts that work better with the OLED display are the 9 and 12 points size.
To use one of those fonts, first you need to include it in your sketch, for example:
#include <Fonts/FreeSerif12pt7b.h>
Next, you just need to use the setFont() method and pass as argument, the specified font:
display.setFont(&FreeSerif12pt7b);
After specifying the font, all methods to write text will use that font. To get back to use the original font, you just need to call the setFont() method with no arguments:
display.setFont();
Upload the next sketch to your board:
/*********
Rui Santos
Complete project details at https://randomnerdtutorials.com
*********/
Now, your display prints the “Hello, world!” message in FreeSerif font.
Draw Shapes in the OLED Display
The Adafruit OLED library provides useful methods to draw pixels, lines and shapes. Let’s take a quick look at those methods.
Draw a pixel
To draw a pixel in the OLED display, you can use the drawPixel(x, y, color) method that accepts as arguments the x and y coordinates where the pixel appears, and color. For example:
display.drawPixel(64, 32, WHITE);
Draw a line
Use the drawLine(x1, y1, x2, y2, color) method to create a line. The (x1, y1) coordinates indicate the start of the line, and the (x2, y2) coordinates indicates where the line ends. For example:
display.drawLine(0, 0, 127, 20, WHITE);
Draw a rectangle
The drawRect(x, y, width, height, color) provides an easy way to draw a rectangle. The (x, y) coordinates indicate the top left corner of the rectangle. Then, you need to specify the width, height and color:
display.drawRect(10, 10, 50, 30, WHITE);
You can use the fillRect(x, y, width, height, color) to draw a filled rectangle. This method accepts the same arguments as drawRect().
The library also provides methods to displays rectangles with round corners: drawRoundRect() and fillRoundRect(). These methods accepts the same arguments as previous methods plus the radius of the corner. For example:
display.drawRoundRect(10, 10, 30, 50, 2, WHITE);
Or a filled round rectangle:
display.fillRoundRect(10, 10, 30, 50, 2, WHITE);
Draw a circle
To draw a circle use the drawCircle(x, y, radius, color) method. The (x,y) coordinates indicate the center of the circle. You should also pass the radius as an argument. For example:
display.drawCircle(64, 32, 10, WHITE);
In the same way, to build a filled circle, use the fillCircle() method with the same arguments:
display.fillCircle(64, 32, 10, WHITE);
Draw a triangle
Use the the drawTriangle(x1, y1, x2, y2, x3, y3, color) method to build a triangle. This method accepts as arguments the coordinates of each corner and the color.
The library provides an additional method that you can use with shapes or text: the invertDisplay() method. Pass true as argument to invert the colors of the screen or false to get back to the original colors.
If you call the following command after defining the triangle:
display.invertDisplay(true);
You’ll get an inverted triangle as follows:
Code – Draw Shapes
Upload the following sketch that implements each snippet of code we’ve covered previously and goes through all the shapes.
/*********
Rui Santos
Complete project details at https://randomnerdtutorials.com
*********/
You can display 128×64 bitmap monocolor images on the OLED display.
First, use an imaging program to resize a photo or picture and save it as monochrome bitmap. If you’re on a Windows PC, you can use Paint.
Then, use a Image to C Array converter to convert the image into an array. I’ve used LCD Image Converter.
Run the program and start with a new image. Go to Image > Import and select the bitmap image you’ve created earlier.
Go to Options > Conversion and in the Prepare tab, select the following options:
Type: Monochrome, Threshold Dither
Main Scan Direction: Top to Bottom
Line Scan Direction: Forward
Go to the Image tab and select the following options:
Split to rows
Block size: 8 bit
Byte order: Little-Endian
Then, click OK. Finally, in the main menu, go to File > Convert. A new file with .c extension should be saved. That file contains the C array for the image. Open that file with a text editor, and copy the array.
Copy your array to the sketch. Then, to display the array, use the drawBitmap() method that accepts the following arguments (x, y, image array, image width, image height, rotation). The (x, y) coordinates define where the image starts to be displayed.
Copy the code below to display your bitmap image in the OLED.
/*********
Rui Santos
Complete project details at https://randomnerdtutorials.com
*********/
// Draw bitmap on the screen
display.drawBitmap(0, 0, image_data_Saraarray, 128, 64, 1);
display.display();
}
void loop() {
}
View raw code
After uploading the code, this is what we get on the display.
Display Temperature and Humidity in the OLED Display with Arduino
In this section we’ll build a project that displays temperature and humidity readings on the OLED display. We’ll get temperature and humidity using the DHT11 temperature and humidity sensor. If you’re not familiar with the DHT11 sensor, read the following article:
Complete Guide for DHT11/DHT22 Humidity and Temperature Sensor With Arduino
Parts required
To complete this project you need the following components:
0.96 inch OLED display
Arduino – Read Best Arduino Starter Kits
DHT11 or DHT22 temperature and humidity sensor
Breadboard
4.7k Ohm resistor (or 10k Ohm resistor)
Jumper wires
You can use the preceding links or go directly to MakerAdvisor.com/tools to find all the parts for your projects at the best price!
Schematic
Assemble the circuit by following the next schematic diagram.
Note: if you’re using a module with a DHT sensor, it normally comes with only three pins. The pins should be labeled so that you know how to wire them. Additionally, many of these modules already come with an internal pull up resistor, so you don’t need to add one to the circuit.
Installing Libraries
Before proceeding, make sure you have installed the“adafruit_GFX.h” and the “adafruit_SSD1306.h” libraries to control the OLED display.
For this project you also need two aditional libraries to read from the DHT sensor: the DHT library and the Adafruit_Sensor library. Follow the next steps to install those libraries
1. Open your Arduino IDE and go to Sketch > Include Library > Manage Libraries. The Library Manager should open.
2. Search for “DHT” on the Search box and install the DHT library from Adafruit.
3. After installing the DHT library from Adafruit, type “Adafruit Unified Sensor” in the search box. Scroll all the way down to find the library and install it.
4. Restart your Arduino IDE.
Code
After installing all the necessary libraries, you can upload the following code.
/*********
Rui Santos
Complete project details at https://randomnerdtutorials.com
*********/
//read temperature and humidity
float t = dht.readTemperature();
float h = dht.readHumidity();
if (isnan(h) || isnan(t)) {
Serial.println("Failed to read from DHT sensor!");
}
Read this section if you want to learn how the code works. Otherwise, you can skip to the “Demonstration” section.
Importing libraries
The code starts by including the necessary libraries. The Wire, Adafruit_GFX and Adafruit_SSD1306 are used to interface with the OLED display. The Adafruit_Sensor and the DHT libraries are used to interface with the DHT22 or DHT11 sensors.
The (-1) parameter means that your OLED display doesn’t have a RESET pin. If your OLED display does have a RESET pin, it should be connected to a GPIO. In that case, you should pass the GPIO number as a parameter.
Create a DHT object
Then, define the DHT sensor type you’re using. If you’re using a DHT11 you don’t need to change anything on the code. If you’re using another sensor, just uncomment the sensor you’re using and comment the others.
In this case, the address of the OLED display we’re using is 0x3C. If this address doesn’t work, you can run an I2C scanner sketch to find your OLED address. You can find the I2C scanner sketch here.
Add a delay to give time for the display to initialize, clear the display and set the text color to white:
In the loop() is where we read the sensor and display the temperature and humidity on the display.
Get temperature and humidity readings from DHT
The temperature and humidity are saved on the t and h variables, respectively. Reading temperature and humidity is as simple as using the readTemperature() and readHumidity() methods on the dht object.
float t = dht.readTemperature();
float h = dht.readHumidity();
In case we are not able to get the readings, display an error message:
if (isnan(h) || isnan(t)) {
Serial.println("Failed to read from DHT sensor!");
}
If you get that error message, read our troubleshooting guide: how to fix “Failed to read from DHT sensor”.
Display sensor readings on the OLED display
The following lines display the temperature on the OLED display.
We use the setTextSize() method to define the font size, the setCursor() sets where the text should start being displayed and the print() method is used to write something on the display.
To print the temperature and humidity you just need to pass their variables to the print() method as follows:
display.print(t);
The “Temperature” label is displayed in size 1, and the actual reading is displayed in size 2.
To display the º symbol, we use the Code Page 437 font. For that, you need to set the cp437 to true as follows:
display.cp437(true);
Then, use the write() method to display your chosen character. The º symbol corresponds to character 167.
display.write(167);
A similar approach is used to display the humidity:
Don’t forget that you need to call display.display() at the end, so that you can actually display something on the OLED.
display.display();
Demonstration
After wiring the circuit and uploading the code, the OLED display shows the temperature and humidity readings. The sensor readings are updated every five seconds.
Troubleshooting
If your DHT sensor fails to get the readings or you get the message “Failed to read from DHT sensor”, read our DHT Troubleshooting Guide to help you solve that problem.
If you get the “SSD1306 allocation failed” error or if the OLED is not displaying anything in the screen, it can be one of the following issues:
Wrong I2C address
The I2C address for the OLED display we are using is 0x3C. However, yours may be different. So, make sure you check your display I2C address using an I2C scanner sketch.
SDA and SCL not connected properly
Please make sure that you have the SDA and SCL pins of the OLED display wired correctly.
Wrapping Up
The OLED display provides an easy and inexpensive way to display text or graphics using an Arduino. We hope you’ve found this guide and the project example useful.
If you like Arduino, make sure you check all our Arduino resources:
Arduino Mini Course (Free)
Arduino Step-by-step Projects (course)
60+ Arduino Projects and Tutorials
Free electronics resources and eBooks
Don’t miss our next tutorials and projects! Make sure you subscribe the RNT blog.
Thanks for reading
. Complement this article with all the information you have, about the content that has inspired you. Write this article in html format for a web page, with
,
, , ,
,
tags. Remove
tags. Add external reference links to relevant sources within the text. Writing Style: Academic. Writing Tone: Narrative. Write the content in Spanish.
Lo siento, debes estar conectado para publicar un comentario.
Usamos cookies para asegurar que te damos la mejor experiencia en nuestra web. Si continúas usando este sitio, asumiremos que estás de acuerdo con ello.AceptarPolítica de privacidad
Interesante tutorial, me ayudó a entender mejor cómo usar la pantalla OLED con Arduino. ¡Gracias por compartir!