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

PASO 2:

Instalar la Librería u8g2

Programa→Incluir Librería→Administrar Biblioteca

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)

No comments at this moment
Producto agregado a favoritos
Producto añadido para comparar.