Tu carrito
No hay más productos en tu carrito
- Dualtronica
- Dualtronica
- 1 likes
- 1713 views
- 0 comments
.jpg)
Pantalla Grafica 12864:
La pantalla LCD 12864 es una pantalla de matriz de puntos monocromática que consta de 128 píxeles por 64 píxeles. Es una pantalla muy popular para usar en proyectos de bricolaje y electrónica, ya que es relativamente barata y fácil de usar. .
La pantalla LCD 12864 está impulsada por el controlador ST7920. Este controlador es responsable de generar la imagen que se muestra en la pantalla. El ST7920 tiene una serie de características que lo hacen adecuado para usar con la pantalla LCD 12864, que incluyen:
• Un amplio rango de voltaje de funcionamiento: el ST7920 puede funcionar con voltajes de 3 V a 5 V. Esto lo hace compatible con una amplia gama de microcontroladores como lo son Arduino y ESP32
• Interfaz de datos paralela: el ST7920 tiene una interfaz de datos paralela de 8 bits. Esto significa que puede enviar datos a la pantalla 8 bits a la vez, lo que lo hace relativamente rápido.
• Interfaz de comandos seriales: el ST7920 también tiene una interfaz de comandos seriales. Esto le permite enviar comandos a la pantalla un byte a la vez, lo que lo hace más flexible que una interfaz de datos paralela.
Las características de la pantalla LCD 12864 con controlador ST7920 incluyen:
• Resolución: 128 x 64 píxeles
• Tamaño de pantalla: 2,9 pulgadas
• Voltaje de funcionamiento: 3 V a 5 V
• Interfaz de datos: paralelo de 8 bits, serie o spi
• Controlador: ST7920
• Color de fondo: azul
• Color de texto: blanco
La pantalla LCD 12864 se puede utilizar para una variedad de aplicaciones, que incluyen:
• Mostrar información, como la hora, la fecha y la temperatura
• Visualización de gráficos, como barras y gráficos
• Mostrar texto, como mensajes y desplazamiento de texto
• Creación de interfaces de usuario para proyectos de bricolaje
La pantalla LCD 12864 es una pantalla versátil y fácil de usar que se puede usar para una variedad de aplicaciones. Es una opción popular para proyectos de bricolaje y electrónica, debido a su bajo costo y facilidad de uso.
Elementos a utilizar
HARDWARE
• 1 ESP32-WROOM-32
• 1 PANTALLA GRAFICA 12864 CON DRIVER ST7920
• 1 PROTOBOARD
• JUMPER MAHO MACHO
• 1 PROTOBOARD
SOFTWARE
• IDE Arduino Versión 1.8.19
• Librería u8g2
Lo primero que tenemos que hacer es Instalar la librería u8g2 que es la que contiene los driver de la pantalla Grafica
PASO 1:
Abrir el IDE de Arduino
.jpg)
PASO 2:
Instalar la Librería u8g2
Programa→Incluir Librería→Administrar Biblioteca
.jpg)
PASO 3.
Nos Sale el siguiente cuadro, En la Barra de Buscar Colocamos u8g2, salen varias librerías debes ubicar la del autor Oliver damos en instalar
Ya tenemos instalado los driver de la pantalla, ahora vamos hacer la conexion de la pantalla grafica y el esp32, la tarjeta esp32 ya debe de estar instalada previamente en el IDE de Arduino
PINES EXTERNOS | PIN ESP32 | PIN PANTALLA |
Negativo | | GND |
5v | | VCC |
| | V0 |
| 5 | RS |
| 21 | R/W |
| 18 | E |
| | DB0 |
| | DB1 |
| | DB2 |
| | DB3 |
| | DB4 |
| | DB5 |
| | DB6 |
| | DB7 |
Negativo | | PSB |
| | NC |
| 19 | RST |
| | VOUT |
| 3,3v | BLA |
Negativo | Negativo | BLK |
Una vez tengamos la libreria de la pantalla y las conexiones realizadas procedemos a copiar y pegar el el siguinete codigo en el IDE de arduino
//--------------------------------------------- INICIO DEL CODIGO------------------------------------------------------------------
#include <Arduino.h>
#include <U8g2lib.h>
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif
//---------------------Driver de la pantalla y configuracion de pines para el ESP32-----------------------------
U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* E=clock=*/ 18, /* R/W=data=*/ 21, /* RS=CS=*/ 5, /* reset=*/ 19); // ESP32 y pantalla
//---------------------------------------------------------------------------------------------------------------
//--------------------Funciones para cada grafica------------------------------------------------------------------
void u8g2_prepare(void) {
u8g2.setFont(u8g2_font_6x10_tf);
u8g2.setFontRefHeightExtendedText();
u8g2.setDrawColor(1);
u8g2.setFontPosTop();
u8g2.setFontDirection(0);
}
void u8g2_box_frame(uint8_t a) {
u8g2.drawStr( 0, 0, "drawBox");
u8g2.drawBox(5, 10, 20, 10);
u8g2.drawBox(10 + a, 15, 30, 7);
u8g2.drawStr( 0, 30, "drawFrame");
u8g2.drawFrame(5, 10 + 30, 20, 10);
u8g2.drawFrame(10 + a, 15 + 30, 30, 7);
}
void u8g2_disc_circle(uint8_t a) {
u8g2.drawStr( 0, 0, "drawDisc");
u8g2.drawDisc(10, 18, 9);
u8g2.drawDisc(24 + a, 16, 7);
u8g2.drawStr( 0, 30, "drawCircle");
u8g2.drawCircle(10, 18 + 30, 9);
u8g2.drawCircle(24 + a, 16 + 30, 7);
}
void u8g2_r_frame(uint8_t a) {
u8g2.drawStr( 0, 0, "drawRFrame/Box");
u8g2.drawRFrame(5, 10, 40, 30, a + 1);
u8g2.drawRBox(50, 10, 25, 40, a + 1);
}
void u8g2_string(uint8_t a) {
u8g2.setFontDirection(0);
u8g2.drawStr(30 + a, 31, " 0");
u8g2.setFontDirection(1);
u8g2.drawStr(30, 31 + a, " 90");
u8g2.setFontDirection(2);
u8g2.drawStr(30 - a, 31, " 180");
u8g2.setFontDirection(3);
u8g2.drawStr(30, 31 - a, " 270");
}
void u8g2_line(uint8_t a) {
u8g2.drawStr( 0, 0, "drawLine");
u8g2.drawLine(7 + a, 10, 40, 55);
u8g2.drawLine(7 + a * 2, 10, 60, 55);
u8g2.drawLine(7 + a * 3, 10, 80, 55);
u8g2.drawLine(7 + a * 4, 10, 100, 55);
}
void u8g2_triangle(uint8_t a) {
uint16_t offset = a;
u8g2.drawStr( 0, 0, "drawTriangle");
u8g2.drawTriangle(14, 7, 45, 30, 10, 40);
u8g2.drawTriangle(14 + offset, 7 - offset, 45 + offset, 30 - offset, 57 + offset, 10 - offset);
u8g2.drawTriangle(57 + offset * 2, 10, 45 + offset * 2, 30, 86 + offset * 2, 53);
u8g2.drawTriangle(10 + offset, 40 + offset, 45 + offset, 30 + offset, 86 + offset, 53 + offset);
}
void u8g2_ascii_1() {
char s[2] = " ";
uint8_t x, y;
u8g2.drawStr( 0, 0, "ASCII page 1");
for ( y = 0; y < 6; y++ ) {
for ( x = 0; x < 16; x++ ) {
s[0] = y * 16 + x + 32;
u8g2.drawStr(x * 7, y * 10 + 10, s);
}
}
}
void u8g2_ascii_2() {
char s[2] = " ";
uint8_t x, y;
u8g2.drawStr( 0, 0, "ASCII page 2");
for ( y = 0; y < 6; y++ ) {
for ( x = 0; x < 16; x++ ) {
s[0] = y * 16 + x + 160;
u8g2.drawStr(x * 7, y * 10 + 10, s);
}
}
}
void u8g2_extra_page(uint8_t a)
{
u8g2.drawStr( 0, 0, "Unicode");
u8g2.setFont(u8g2_font_unifont_t_symbols);
u8g2.setFontPosTop();
u8g2.drawUTF8(0, 24, "☀ ☁");
switch (a) {
case 0:
case 1:
case 2:
case 3:
u8g2.drawUTF8(a * 3, 36, "☂");
break;
case 4:
case 5:
case 6:
case 7:
u8g2.drawUTF8(a * 3, 36, "☔");
break;
}
}
#define cross_width 24
#define cross_height 24
static const unsigned char cross_bits[] U8X8_PROGMEM = {
0x00, 0x18, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x42, 0x00,
0x00, 0x42, 0x00, 0x00, 0x42, 0x00, 0x00, 0x81, 0x00, 0x00, 0x81, 0x00,
0xC0, 0x00, 0x03, 0x38, 0x3C, 0x1C, 0x06, 0x42, 0x60, 0x01, 0x42, 0x80,
0x01, 0x42, 0x80, 0x06, 0x42, 0x60, 0x38, 0x3C, 0x1C, 0xC0, 0x00, 0x03,
0x00, 0x81, 0x00, 0x00, 0x81, 0x00, 0x00, 0x42, 0x00, 0x00, 0x42, 0x00,
0x00, 0x42, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x18, 0x00,
};
#define cross_fill_width 24
#define cross_fill_height 24
static const unsigned char cross_fill_bits[] U8X8_PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x18, 0x64, 0x00, 0x26,
0x84, 0x00, 0x21, 0x08, 0x81, 0x10, 0x08, 0x42, 0x10, 0x10, 0x3C, 0x08,
0x20, 0x00, 0x04, 0x40, 0x00, 0x02, 0x80, 0x00, 0x01, 0x80, 0x18, 0x01,
0x80, 0x18, 0x01, 0x80, 0x00, 0x01, 0x40, 0x00, 0x02, 0x20, 0x00, 0x04,
0x10, 0x3C, 0x08, 0x08, 0x42, 0x10, 0x08, 0x81, 0x10, 0x84, 0x00, 0x21,
0x64, 0x00, 0x26, 0x18, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
#define cross_block_width 14
#define cross_block_height 14
static const unsigned char cross_block_bits[] U8X8_PROGMEM = {
0xFF, 0x3F, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20,
0xC1, 0x20, 0xC1, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20,
0x01, 0x20, 0xFF, 0x3F,
};
void u8g2_bitmap_overlay(uint8_t a) {
uint8_t frame_size = 28;
u8g2.drawStr(0, 0, "Bitmap overlay");
u8g2.drawStr(0, frame_size + 12, "Solid / transparent");
u8g2.setBitmapMode(false /* solid */);
u8g2.drawFrame(0, 10, frame_size, frame_size);
u8g2.drawXBMP(2, 12, cross_width, cross_height, cross_bits);
if (a & 4)
u8g2.drawXBMP(7, 17, cross_block_width, cross_block_height, cross_block_bits);
u8g2.setBitmapMode(true /* transparent*/);
u8g2.drawFrame(frame_size + 5, 10, frame_size, frame_size);
u8g2.drawXBMP(frame_size + 7, 12, cross_width, cross_height, cross_bits);
if (a & 4)
u8g2.drawXBMP(frame_size + 12, 17, cross_block_width, cross_block_height, cross_block_bits);
}
void u8g2_bitmap_modes(uint8_t transparent) {
const uint8_t frame_size = 24;
u8g2.drawBox(0, frame_size * 0.5, frame_size * 5, frame_size);
u8g2.drawStr(frame_size * 0.5, 50, "Black");
u8g2.drawStr(frame_size * 2, 50, "White");
u8g2.drawStr(frame_size * 3.5, 50, "XOR");
if (!transparent) {
u8g2.setBitmapMode(false /* solid */);
u8g2.drawStr(0, 0, "Solid bitmap");
} else {
u8g2.setBitmapMode(true /* transparent*/);
u8g2.drawStr(0, 0, "Transparent bitmap");
}
u8g2.setDrawColor(0);// Black
u8g2.drawXBMP(frame_size * 0.5, 24, cross_width, cross_height, cross_bits);
u8g2.setDrawColor(1); // White
u8g2.drawXBMP(frame_size * 2, 24, cross_width, cross_height, cross_bits);
u8g2.setDrawColor(2); // XOR
u8g2.drawXBMP(frame_size * 3.5, 24, cross_width, cross_height, cross_bits);
}
uint8_t draw_state = 0;
void draw(void) {
u8g2_prepare();
switch (draw_state >> 3) {
case 0: u8g2_box_frame(draw_state & 7); break;
case 1: u8g2_disc_circle(draw_state & 7); break;
case 2: u8g2_r_frame(draw_state & 7); break;
case 3: u8g2_string(draw_state & 7); break;
case 4: u8g2_line(draw_state & 7); break;
case 5: u8g2_triangle(draw_state & 7); break;
case 6: u8g2_ascii_1(); break;
case 7: u8g2_ascii_2(); break;
case 8: u8g2_extra_page(draw_state & 7); break;
case 9: u8g2_bitmap_modes(0); break;
case 10: u8g2_bitmap_modes(1); break;
case 11: u8g2_bitmap_overlay(draw_state & 7); break;
}
}
//---------------------------------------fin de las funciones-----------------------------------------------------
//-------------------------------------- inicializacion de la pantalla Grafica 12864 st7920------------------------
void setup(void) {
u8g2.begin();
}
//------------------------------------------------------------------------------------------------------------------
//-----------------------------------------codigo principal bucle, llamado de cada funcion----------------------------
void loop(void) {
// picture loop
u8g2.clearBuffer(); // limpiamos el buffer
draw(); // llamamos a la funcion draw, la cual es un swith y esta a su vez contiene las demas funciones
u8g2.sendBuffer(); // enviamos el contenido a la pantalla
// increase the state
draw_state++;
if ( draw_state >= 12 * 8 )
draw_state = 0;
// deley between each page
delay(100);
}
//--------------------------------------------- FIN DEL CODIGO------------------------------------------------------------------
CONTROLADOR DE PANTALLA:
U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* E=clock=*/ 18, /* R/W=data=*/ 21, /* RS=CS=*/ 5, /* reset=*/ 19); // ESP32 y pantalla
la linea Anterior es la que controla la pantalla, en donde indicas qué pines vas a definir para poder conectarlos a la tarjeta de desarrollo, en este caso la ESP32. Igual la puedes utilizar con Arduino Mega. esta librería ocupa mucho espacio y probablemente te quedes corto de memoria si utilizas Arduino Uno, nano, mini.
PINES QUE UTILIZAMOS DE LA PANTALLA Y DEL ESP32
E=Clock= 18,
R/W=Data= 21,
RS=CS= 5,
Reset=19
Sensor de Temperartura y humedad DHT22 con esp32 y pantalla 12864
Comments (0)