Giao Tiếp GLCD 128x64

Giới thiệu

GLCD là một thiết bị hiển thị có thể được sử dụng trong các hệ thống nhúng để hiển thị dữ liệu và / hoặc hình ảnh / ký tự tùy chỉnh.

• Về cơ bản, LCD đồ họa 128x64 là một ma trận pixel.
• Mỗi pixel được truy cập theo địa chỉ X và Y của chúng.
• Chúng ta chỉ có thể hình dung bất kỳ pixel nào bằng cách làm cho giá trị của nó HIGH (1).

Do đó, chúng ta có thể tạo bất kỳ pixel thiết kế đồ họa nào bằng pixel bằng GLCD.

Để làm quen với các chân GLCD và các chức năng của GLCD 128x64 vui lòng sử dụng công cụ timg kiếm của Google..

Cấu trúc cơ bản của màn hình GLCD 128x64

Lập trình GLCD

Hãy chương trình vi điều khiển AT89S51 để in ký tự chữ trên GLCD JHD12864E.

Khởi tạo

Để khởi tạo màn hình, chúng ta cần thực hiện các bước dưới đây,

• Gửi lệnh OFF hiển thị tức là 0x3E
• Gửi địa chỉ Y, ví dụ tại đây 0x40 (Địa chỉ xuất phát).
• Gửi địa chỉ X (Trang) ví dụ ở đây 0xB8 (Trang0).
• Gửi địa chỉ Z (dòng bắt đầu), ví dụ ở đây 0xC0 (từ dòng 0).
• Bây giờ gửi lệnh Hiển thị ON tức là 0x3F

Hàm GLCD_Init

Đối số đầu vào: Nó không có đối số đầu vào.

Kiểu trả về: Nó không trả về bất kỳ kiểu dữ liệu nào.

void GLCD_Init()  /* GLCD initialize function */
{
 CS1 = 1; CS2 = 1; /* Select left & right half of display */ 
 RST = 1;  /* Keep reset pin high */
 delay(20);
 GLCD_Command(0x3E); /* Display OFF */
 GLCD_Command(0x40); /* Set Y address (column=0) */
 GLCD_Command(0xB8); /* Set x address (page=0) */
 GLCD_Command(0xC0); /* Set z address (start line=0) */
 GLCD_Command(0x3F); /* Display ON */
}

Viết lệnh

Để viết lệnh thực hiện các bước dưới đây

• Gửi lệnh trên chân dữ liệu.
• Thực hiện RS = 0 (Command Register) và RW = 0 (Write Operation).
• Thực hiện chuyển đổi Cao sang Thấp trên Bật pin tối thiểu. 1 chu kỳ.

Hàm GLCD_Command

Đối số đầu vào: Nó có đối số đầu vào của Command.

Kiểu trả về: Nó không trả về bất kỳ kiểu dữ liệu nào.

void GLCD_Command(char Command) /* GLCD command function */
{
 Data_Port = Command; /* Copy command on data pin */
 RS = 0;   /* Make RS LOW to select command register */
 RW = 0;   /* Make RW LOW to select write operation */
 E = 1;   /* Make HIGH to LOW transition on Enable */
 _nop_ ();
 E = 0;     
 _nop_ ();
}

Viết dữ liệu

Để ghi dữ liệu làm các lệnh dưới đây

• Gửi dữ liệu trên các ghim dữ liệu.
• Tạo RS = 1 (Đăng ký dữ liệu) và RW = 0 (Thao tác ghi).
• Thực hiện chuyển đổi Cao sang Thấp trên Bật pin trong thời gian tối thiểu 1 chúng tôi.

Hàm GLCD_Data

Đối số đầu vào: Nó có đối số đầu vào Dữ liệu.

Kiểu trả về: Nó không trả về bất kỳ kiểu dữ liệu nào.

void GLCD_Data(char Data) /* GLCD data function */
{
 Data_Port = Data; /* Copy data on data pin */
 RS = 1;   /* Make RS HIGH to select data register */
 RW = 0;   /* Make RW LOW to select write operation */
 E = 1;   /* Make HIGH to LOW transition on Enable */
 _nop_ ();
 E = 0;
 _nop_ ();
}

Sơ đồ

Giao diện GLCD 128x64 với 8051

Chương trình in văn bản

#include <reg51.h>  /* Include reg51 header file */
#include <intrins.h>  /* Include intrinsic header file */
#include "Font_Header.h" /* Include font header file */

#define Data_Port P3  /* Define data port for GLCD */

sbit RS = P2^0;   /* Set control bits pins */
sbit RW = P2^1;
sbit E = P2^2;
sbit CS1 = P2^3;
sbit CS2 = P2^4;
sbit RST = P2^5;


void delay(k)   /* Delay of msec with xtal = 11.0592MHz */
{
 int i,j;
 for (i=0;i<k;i++)
  for (j=0;j<112;j++);
}

void GLCD_Command(char Command) /* GLCD command function */
{
 Data_Port = Command; /* Copy command on data pin */
 RS = 0;   /* Make RS LOW to select command register */
 RW = 0;   /* Make RW LOW to select write operation */
 E = 1;   /* Make HIGH to LOW transition on Enable */
 _nop_ ();
 E = 0;              
 _nop_ ();
}

void GLCD_Data(char Data) /* GLCD data function */
{
 Data_Port = Data; /* Copy data on data pin */
 RS = 1;   /* Make RS HIGH to select data register */
 RW = 0;   /* Make RW LOW to select write operation */
 E = 1;   /* Make HIGH to LOW transition on Enable */
 _nop_ ();
 E = 0;
 _nop_ ();
}

void GLCD_Init()  /* GLCD initialize function */
{
 CS1 = 1; CS2 = 1; /* Select left & right half of display */
 RST = 1;  /* Keep reset pin high */ 
 delay(20);
 GLCD_Command(0x3E); /* Display OFF */
 GLCD_Command(0x40); /* Set Y address (column=0) */
 GLCD_Command(0xB8); /* Set x address (page=0) */
 GLCD_Command(0xC0); /* Set z address (start line=0) */
 GLCD_Command(0x3F); /* Display ON */
}

void GLCD_ClearAll()  /* GLCD all display clear function */
{
 int i,j;
 CS1 = 1; CS2 = 1; /* Select left & right half of display */
 for(i=0;i<8;i++)
 {
  GLCD_Command((0xB8)+i); /* Increment page */
  for(j=0;j<64;j++)
  {
   GLCD_Data(0); /* Write zeros to all 64 column */
  }
 }
 GLCD_Command(0x40); /* Set Y address (column=0) */
 GLCD_Command(0xB8); /* Set x address (page=0) */
}

void GLCD_String(char page_no, char *str) /* GLCD string write function */
{
 unsigned int i,column,Page=((0xB8)+page_no),Y_address=0; 
 float Page_inc=0.5;              
 CS1 = 1; CS2 = 0;
 GLCD_Command(Page);
 for(i=0;str[i]!=0;i++)
 {
 if (Y_address>(1024-(((page_no)*128)+5)))
  break;
  if (str[i]!=32)
  {
   for (column=1;column<=5;column++)
   {
    if ((Y_address+column)==(128*((int)(Page_inc+0.5))))      {
     if (column==5)
        break;
     GLCD_Command(0x40);
     Y_address = Y_address+column;
     CS1 = ~CS1; CS2 = ~CS2;
     GLCD_Command((Page+Page_inc));
     Page_inc=Page_inc+0.5;
    }
   }
  }
 if (Y_address>(1024-(((page_no)*128)+5
 break;
 if((font[((str[i]-32)*5)+4])==0 || str[i]==32)
 {
  for(column=0;column<5;column++)
  {
   GLCD_Data(font[str[i]-32][column]);
   if((Y_address+1)%64==0)
   {
    CS1 = ~CS1; CS2 = ~CS2;
    GLCD_Command((Page+Page_inc));
    Page_inc=Page_inc+0.5;
   }
   Y_address++;
  }
 }
 else
 {
  for(column=0;column<5;column++)
  {
   GLCD_Data(font[str[i]-32][column]);
   if((Y_address+1)%64==0)
    {
     CS1 = ~CS1; CS2 = ~CS2;
     GLCD_Command((Page+Page_inc));
     Page_inc=Page_inc+0.5;
    }
    Y_address++;
   }
   GLCD_Data(0);
   Y_address++;
   if((Y_address)%64==0)
   {
    CS1 = ~CS1; CS2 = ~CS2;
    GLCD_Command((Page+Page_inc));
    Page_inc=Page_inc+0.5;
   }
  }
 }
 GLCD_Command(0x40);  /* Set Y address (column=0) */
}

void main()
{
 GLCD_Init();  /* Initialize GLCD */
 GLCD_ClearAll(); /* Clear all GLCD display */
 GLCD_String(0,"8051 Microcontroller");  /* Print String at 0th page of display */
 while(1);
}

Hình ảnh đầu ra

In văn bản hiển thị GLCD

Lập trình 8.051 để hiển thị hình ảnh trên GLCD

Chúng tôi đang sử dụng cùng một chức năng được sử dụng để hiển thị văn bản ngoại trừ chức năng GLCD_String, được sửa đổi ở đây để in dữ liệu hình ảnh trên GLCD.

• Ở đây chúng tôi đang sử dụng vi điều khiển AT89S51 để giao tiếp với GLCD. Nó có giới hạn RAM 128 byte.
• Hình ảnh nhị phân có tổng kích thước là 128x64 pixel. Vì vậy, chúng ta cần một mảng 1024 byte [(128 * 64) / 8 = 1024 byte] để lưu trữ hình ảnh trong vi điều khiển.
• Bây giờ vấn đề là, chúng tôi không thể xác định một mảng có kích thước 1024 trong RAM (bộ nhớ dữ liệu) vì nó chỉ là 128 byte. Chúng ta phải lưu nó trong ROM (bộ nhớ mã). Để xác định bất kỳ biến nào trong bộ nhớ mã, chúng ta phải sử dụng từ khóa “code”. 

ví dụ

unsigned char[ ]= "ABCDEFG";       /* array defined in Data memory (RAM) */
code unsigned char[ ]= "ABCDEFG";  /* array defined in Code memory (ROM) */

Tuy nhiên, mảng được xác định trong bộ nhớ mã sẽ mất nhiều thời gian hơn để truy cập, 8051 sử dụng lệnh “movc A, A + DPTR”, thường mất nhiều chu kỳ máy hơn để thực thi.

• Mảng hình ảnh được định nghĩa trong tệp Image.h.

Chương trình in ảnh

#include <reg51.h>  /* Include reg51 header file */
#include <intrins.h>  /* Include intrinsic header file */
#include "Image.h"  /* Include image header file */
#define Data_Port P3  /* Define data port for GLCD */

sbit RS = P2^0;   /* Set control bits pins */
sbit RW = P2^1;
sbit E = P2^2;
sbit CS1 = P2^3;
sbit CS2 = P2^4;
sbit RST = P2^5;

void delay(k)   /* Delay of msec with xtal = 11.0592MHz */
{
 int i,j;
 for (i=0;i<k;i++)
  for (j=0;j<112;j++);
}

void GLCD_Command(char Command) /* GLCD command function */
{
 Data_Port = Command; /* Copy command on data pin */
 RS = 0;   /* Make RS LOW to select command register */
 RW = 0;   /* Make RW LOW to select write operation */
 E = 1;   /* Make HIGH to LOW transition on Enable */
 _nop_ ();
 E = 0;           
 _nop_ ();
}

void GLCD_Data(char Data) /* GLCD data function */
{
 Data_Port = Data; /* Copy data on data pin */
 RS = 1;   /* Make RS HIGH to select data register */
 RW = 0;   /* Make RW LOW to select write operation */
 E = 1;   /* Make HIGH to LOW transition on Enable */
 _nop_ ();
 E = 0;
 _nop_ ();
}

void GLCD_Init()  /* GLCD initialize function */
{
 CS1 = 1; CS2 = 1; /* Select left & right half of display */
 RST = 1;  /* Keep reset pin high */ 
 delay(20);
 GLCD_Command(0x3E); /* Display OFF */
 GLCD_Command(0x40); /* Set Y address (column=0) */
 GLCD_Command(0xB8); /* Set x address (page=0) */
 GLCD_Command(0xC0); /* Set z address (start line=0) */
 GLCD_Command(0x3F); /* Display ON */
}
void GLCD_ClearAll()  /* GLCD all display clear function */

 int i,j;
 CS1 = 1; CS2 = 1; /* Select left & right half of display */
 for(i=0;i<8;i++)
 {
  GLCD_Command((0xB8)+i); /* Increment page */
  for(j=0;j<64;j++)
  {
   GLCD_Data(0); /* Write zeros to all 64 column */
  }
 }
 GLCD_Command(0x40);  /* Set Y address (column=0) */
 GLCD_Command(0xB8);  /* Set x address (page=0) */
}


void GLCD_String(char *str)  /* GLCD string write function */
{
 int column,page,page_add=0xB8,k=0;
 float page_inc=0.5;
 CS1 = 1; CS2 = 0;
 for(page=0;page<16;page++) 
 {
  for(column=0;column<64;column++)
  {
   GLCD_Data(str[column+k]);
  }
  CS1 = ~CS1; CS2 = ~CS2;
  GLCD_Command((page_add+page_inc));
  page_inc=page_inc+0.5;
  k=k+64;
 }
 GLCD_Command(0x40);
 GLCD_Command(0xB8);
}

void main()
{
 GLCD_Init();   /* Initialize GLCD */     
 GLCD_ClearAll();  /* Clear all screen */
 GLCD_String(img);  /* Print image */
 while(1);
}

Hình ảnh đầu ra

Hiển thị hình ảnh GLCD

Hoạt hình trên GLCD 

Để tạo hoạt ảnh trên màn hình GLCD 128x64 JHD12864E, hãy thực hiện các bước dưới đây,

• Chụp hai hoặc nhiều hình ảnh theo cách mà trình tự của chúng sẽ tạo ra ảo tưởng về chuyển động.
• Chuyển đổi nó sang dữ liệu hình ảnh nhị phân bằng ứng dụng Image2GLCD.
• Và in chúng trên GLCD theo chuỗi. Nó sẽ tạo ra hình ảnh động.
• Lưu ý rằng cung cấp đủ độ trễ giữa các hình ảnh.

Code mô phỏng
+ Animal GLCD
+ Image GLCD
+ Tex GLCD

Tệp đính kèm
Datasheet