Los diodos emisores de luz orgánicos o pantallas OLED se han vuelto esenciales para muchos dispositivos integrados. Las OLED se consideran una de las pantallas de mayor calidad para mostrar información del dispositivo.
Normalmente, los dispositivos integrados utilizan gráficos de pantalla única, pero se requieren interfaces complejas cuando hay múltiples interacciones de usuarios. Por ejemplo, dichas interfaces pueden utilizar menús u otra navegación gráfica. Agregar un menú de varias páginas o GUI a pantallas integradas es una tarea complicada. Los microcontroladores tienen memoria flash y RAM limitadas, por lo que no pueden albergar interfaces gráficas ricas.
La única alternativa es el texto animado. El texto se puede animar para mostrar menús y submenús, mostrar múltiples pantallas de navegación y alojar interfaces de usuario multipantalla.
En este proyecto, alojaremos una interfaz multipantalla en un OLED SSD1306 controlado por un microcontrolador ESP8266. MicroPython es el firmware integrado, por lo que utilizaremos un script MicroPython integrado para alojar la interfaz del SSD1306. La interfaz de usuario mostrará una colección de pantallas con texto animado horizontal y vertical.
Componentes necesarios
1.ESP8266x1
2. SSD1306 OLEDx1
3. Hilos Dupont
4. Cable micro USB (para conectar el ESP8266 a la computadora)
Conexiones de circuito
Conecte SSD1306 OLED con ESP8266 usando el software SPI.
- Los pines DC, RST y CS del OLED se conectan con GPIO4, GPIO5 y GPIO15.
- Los pines OLED D0 y D1 se conectan a GPIO14 y GPIO13.
- Los pines VCC y GND del OLED se conectan a la salida 3V y GND del ESP8266.
Preparando el ESP8266
El IDE de MicroPython debe estar listo para escribir, editar y cargar código antes de continuar con este proyecto. Puede utilizar uPyCraft IDE o Thonny IDE para el desarrollo de software. Asegúrese de que el firmware MicroPython se haya cargado correctamente en el ESP8266. Aprende cómo aquí .
Ampliando la biblioteca ssd1306.py para animación de texto
El firmware MicroPython contiene la biblioteca para el SSD1306 OLED. Para trabajar con SSD1306 OLED usando MicroPython, primero aprenda cómo conectar SSD1306 con ESP32 y ESP8266 . Notarás que el enlace de Github al código fuente de MicroPython ha cambiado. El código fuente en Github también excluye la biblioteca SSD1306. Afortunadamente, la biblioteca todavía está disponible en código fuente en el sitio web oficial .
Esta biblioteca es suficiente para interconectar el SSD1306 OLED con puertos MicroPython, especialmente a través del puerto SPI. La interfaz a través del puerto I2C ya no funciona correctamente.
La biblioteca debe ampliarse para crear animaciones de texto. Se deben agregar los siguientes métodos a la clase SSD1306 de la biblioteca.
def llenar(self, col):
self.framebuf.relleno(col)
def píxel(self, x, y, col):
self.framebuf.pixel(x, y, col)
def desplazamiento(self, dx, dy):
self.framebuf.scroll(dx,dy)
def texto(self, string, x, y, col=1):
self.framebuf.text(cadena, x, y, col)
Los métodos agregados a la clase SSD1306 se denominan igual que en la clase MicroPython FrameBuffer. La clase FrameBuffer proporciona un búfer de píxeles que representa un píxel, una línea, una forma o un texto.
Estos métodos FrameBuffer se utilizan para ampliar la biblioteca….
- FrameBuffer.fill(c) : rellena todo el framebuffer con un color específico. El controlador OLED SSD1306 utiliza este método para llenar la pantalla OLED con colores monocromáticos.
- FrameBuffer.pixel(x, y(, c)) : se utiliza para obtener o establecer el color de un píxel específico. La posición del píxel se pasa como argumentos 'x' e 'y'. Si se usa para establecer el color del píxel, 'c' es el color pasado como argumento.
- FrameBuffer.scroll(dx,dy) : se utiliza para desplazar el contenido del FrameBuffer según un vector determinado.
- FrameBuffer.text(s, x, y(, c)) : se utiliza para escribir una cadena de texto en la pantalla OLED. El texto comienza a imprimirse en la pantalla desde las posiciones de los píxeles 'x' e 'y'. El color del texto se puede configurar en 'c'.
La biblioteca SSD1306 extendida tiene este código fuente:
Cargando el controlador OLED usando uPyCraft IDE
Para usar uPyCraft IDE para cargar el controlador OLED para ESP8266 o ESP32, conecte la placa a una computadora usando un cable USB. El firmware MicroPython ya debería estar cargado para ESP8266/ESP32 .
Luego seleccione el puerto COM. ESP8266/ESP32 se conecta navegando a Herramientas->Serial. Elija su tablero MicroPython navegando a Herramientas->Tablero. Ahora conecte la placa a uPyCraft IDE haciendo clic en el botón de conexión.
Una vez que la placa esté conectada, navegue hasta boot.py en la carpeta del dispositivo. Para agregar el controlador OLED SSD1306, cree un nuevo archivo navegando a Archivo->Nuevo o haciendo clic en el botón Nuevo.
Copie el código de la biblioteca del controlador OLED SSD1306 y guarde el archivo como ssd1306.py. Luego haga clic en el botón 'Descargar y ejecutar' para cargar el archivo de la biblioteca en ESP8266/ESP32.
Creando pantallas
La interfaz de usuario debe organizarse como pantallas separadas para agregar submenús o un diseño de paneles múltiples. Esto significa que diferentes submenús o paneles de navegación se abren como pantallas separadas en la pantalla. Cada pantalla puede considerarse como una lista de filas de píxeles donde cada fila contiene un texto o una forma.
El siguiente código define tres pantallas diferentes. Cada pantalla es una lista de líneas que contienen texto sin formato.
screen1_row1 = “Pantalla 1, fila 1”
screen1_row2 = “Pantalla 1, fila 2”
screen1_row3 = “Pantalla 1, fila 3”
screen2_row1 = “Pantalla 2, fila 1”
screen2_row2 = “Pantalla 2, fila 2”
screen3_row1 = “Pantalla 3, fila 1”
pantalla1 = ((0, 0, pantalla1_línea1), (0, 16, pantalla1_línea2), (0, 32, pantalla1_línea3)) pantalla2 = ((0, 0, pantalla2_línea1), (0, 16, pantalla2_línea2)) pantalla3 = (( 0, 40, pantalla3_fila1))
Desplazar texto horizontalmente
Para desplazar el texto horizontalmente de izquierda a derecha (con el texto atravesando la pantalla), la coordenada 'x' de cada línea de texto se incrementa en cuatro píxeles en un bucle anidado, hasta que la variable del bucle exceda el ancho del LED.
def scroll_h_in(pantalla):
para i en el rango (0, oled_width+1, 4):
para línea en pantalla:
oled.text(línea(2), -oled_width+i, línea(1))
oled.mostrar
si yo! = ancho_oled:
oled.relleno(0)
Para desplazar el texto horizontalmente de izquierda a derecha (con el texto saliendo de la pantalla), la coordenada 'x' de cada línea se incrementa en el número de píxeles definido por el usuario, hasta que el texto desaparece de la pantalla.
def scroll_h_out(velocidad):
para i en el rango ((oled_width+1)/velocidad):
para j en rango (oled_height):
oled.píxel(i,j,0)
oled.scroll(velocidad,0)
oled.mostrar
Para desplazar el texto horizontalmente hacia adentro y hacia afuera, la coordenada 'x' de cada línea se incrementa continuamente para permitir que el texto se mueva dentro y fuera de la pantalla.
def scroll_h_in_out(pantalla):
para i en el rango (0, (oled_width+1)*2, 1):
para línea en pantalla:
oled.text(línea(2), -oled_width+i, línea(1))
oled.mostrar
si yo! = ancho_oled:
oled.relleno(0)
Desplazar texto verticalmente
Para desplazar el texto verticalmente de arriba a abajo (con el texto en la pantalla), la coordenada 'y' de cada línea se incrementa en cuatro píxeles en un bucle anidado, hasta que la variable del bucle exceda la altura del LED.
def scroll_v_in(pantalla):
para i en el rango (0, (oled_height+1), 1):
para línea en pantalla:
oled.text(línea(2), línea(0), -oled_height+i+línea(1))
oled.mostrar
¡si yo! = altura_oled:
oled.relleno(0)
Para desplazar el texto verticalmente de arriba a abajo (con el texto saliendo de la pantalla), la coordenada 'y' de cada línea se incrementa en el número de píxeles definido por el usuario, hasta que el texto desaparece de la pantalla.
def scroll_v_out(velocidad):
para i en el rango ((oled_height+1)/velocidad):
para j en el rango (oled_width):
oled.pixel(j, i, 0)
oled.scroll(0,velocidad)
oled.mostrar
Para desplazar el texto verticalmente hacia adentro y hacia afuera, la coordenada 'y' de cada línea se incrementa continuamente para permitir que el texto se mueva dentro y fuera de la pantalla.
def scroll_v_in_out(pantalla):
para i en el rango (0, (oled_height*2+1), 1):
para línea en pantalla:
oled.text(línea(2), línea(0), -oled_height+i+línea(1))
oled.mostrar
¡si yo! = altura_oled:
oled.relleno(0)
El script MicroPython
Pruebe el siguiente código en main.py. Este script crea tres pantallas diferentes compuestas de texto sin formato y prueba el desplazamiento horizontal y vertical en cada una.
Como funciona
El script utiliza las funciones agregadas a la biblioteca SSD1306.py. Crea pantallas con texto simple y cambia las posiciones 'x' e 'y' de cada línea para moverse horizontal y verticalmente sobre el marco de la pantalla.
Formularios
El código que se muestra aquí se puede reutilizar para alojar una interfaz de usuario de múltiples menús en un dispositivo integrado con tecnología MicroPython o una interfaz gráfica de múltiples paneles.
Resultados
