A Brief Discussion on Using Single Chip Microcomputer to Control 12864 LCD

Speaking of 12864, there is love and hate.

Let me introduce some background: some time ago, we participated in an electronics competition, the topic was "Wireless Remote Control Drawing Car", which meant to make an A terminal as the remote control part and a B terminal as the drawing main part. Each part is controlled by the main control IC. We use the enhanced 51 single-chip microcomputer STC12C5A32S2. There are two reasons for choosing it: one is that ordinary 51 single-chip microcomputers cannot meet the requirements in terms of main frequency and RAM; the other is that before the competition, we suddenly learned that the 128 of the AVR series was discontinued. The only 128 left on the market has doubled in price, reaching 45~55 yuan per piece, which is too expensive. So I exclaimed: the era of AVR is about to pass. Finally, we chose the STC12C5A32S2 microcontroller, with a main frequency of 24M, without frequency division, which is equivalent to the 288M frequency of the traditional 51 microcontroller, and the speed is sufficient; the 32K+28K memory is enough compared to the 4K and 8K storage space of the 51; and its price is only 7 yuan/chip (purchased directly from the chip manufacturer). In this way, both the performance and price meet the requirements, and it can be said to be a microcontroller with a very high cost performance. Well, the main control is introduced. Because I mainly want to talk about the 12864 LCD this time, I will mainly introduce the A end and its control.

The A end is mainly composed of five parts: power module, main control chip and its working circuit, Omron non-coding 4*4 matrix keyboard, nrf24L01 wireless transmission module, 12864 LCD display module. The following mainly introduces some problems encountered in the use of 12864 LCD and their solutions: (I will give you some suggestions, and welcome your advice)

12864 LCD, literally speaking, is a 128*64 resolution LCD screen, which is the same as the display resolution mentioned in the computer. It's just that 12864 is a monochrome LCD screen, and the most common colors on the market are cyan and blue. We use a blue LCD screen with a Chinese character library, which is much more convenient to use. About Chinese characters and ASCII codes: Chinese characters occupy 16*16 screen space in 12864, and ASCII code characters occupy 16*8 screen space. So we can know: a 12864 uses an internal character library and can display up to 32 Chinese characters or 64 ASCII code characters. If we feel that the screen displays too little, we can abandon the internal character library of the LCD and make a character library ourselves, in which Chinese characters and ASCII codes can occupy 8*8 screen space, so that our 12864 can display up to 128 Chinese characters or ASCII code characters. So this method can be used when there is a lot of content to display.

As a background, let's talk about the driver of 12864. The driving circuit of LCD is quite complicated. An engineer with several years of work experience may not be able to design a 12864 driver by himself. But the good thing is that when we buy 12864, the manufacturer has already made the driver. All we have to do is use it through the 20P interface left by the manufacturer (this is the specialization of the profession. We don't have to care about its internal driver, as long as we can use it). I won't go into the specific name and function of the 20P pin left by the manufacturer. There are a lot of them on the Internet. After the I/O and power lines of the microcontroller are welded to the LCD, the hardware is built. Let's start software programming to control the 12864 LCD to make it display.

When it comes to software programming, we first need to prepare the platform: First: solder a download circuit for the microcontroller. The most commonly used download circuit for the 51 microcontroller is the serial port download, which requires a serial port, 5 104 capacitors, a max232 chip, a serial port cable/USB to serial port cable (the latter is mainly designed for laptops and other computers without serial ports), and several wires. This download circuit is also available on the Internet, so I won’t go into details. Second: a computer (for programming) is required. Third: a corresponding development platform is required. The most commonly used 51 microcontroller is keil, and the more popular ones are keil2 and keil3. Each has its own characteristics and can be selected according to your own habits. I personally choose the keil3 platform. With the above 3 points, the software and hardware development platform has been built. The following introduces program writing.

First, open the Keil software, create a project, and add a file to the project, then you can write the program. First, write the basic program structure: header file, main function, while loop. In order to make the program easier to understand, write functions and call them in the main function. The following introduces the writing of various functional functions.

The first is the most basic initialization operation, which requires reference to the operation timing diagram provided by the manufacturer (not detailed here, only the code is listed)

void init_12864()
{

lcd12864_psb=1; //Select parallel mode
write_cmd(0x30); //Select basic instruction
write_cmd(0x0C); //Turn on the display and turn off the cursor
write_cmd(0x01); //Clear the screen and return the address to zero
}

Next is the basic read and write operation: refer to the operation timing diagram provided by the manufacturer (not detailed here, only the code is listed)

//Write a command byte into 12864
void write_cmd(uchar cmd)
{
lcd12864_rs=0;//Pull the rs pin low to indicate a command
lcd12864_rw=0;//Indicates writing, not reading
P0=cmd;//Send the command byte to the data line

lcd12864_en=0; //Give the en pin a high pulse
delay_ms(5);
lcd12864_en=1;
delay_ms(5);
lcd12864_en=0;
}

//Write a byte of data into 12864
void write_dat(uchar dat)
{
lcd12864_rs=1;//Write data
lcd12864_rw=0;//Write
P0=dat;//Send data to the data line

lcd12864_en=0; // give the en pin a high pulse
delay_ms(5);
lcd12864_en=1;
delay_ms(5);
lcd12864_en=0;
}

The basic function is written. The operation of 12864 is as follows: first, it needs to be configured, that is, the initialization function is executed, and then the characters can be displayed. If we want to display the Chinese character "好" on the screen, we need to do the following: first write the command, the content is the display address (the first line of the first space is 0x80), and then write the data, the content is the character we want to display (the content is "好"), so our code is written like this:

init_12864();

write_cmd(0x80);

write_dat("OK");

In this way, we compile the code and download the file to the microcontroller, and then we can see the word "good" in the upper left corner of the screen on the 12864. Now let's do some more complicated operations. That is, display any string anywhere on the screen (of course, the required display space must be sufficient, otherwise there will be no place to display it). The code is as follows:

void set_xy(uchar row,uchar line) //Set the display address to row x and column y
{
switch(row) //Judge the row
{
case 1: {write_cmd(0x80|line);break;} //First row, set the column positioncase
2: {write_cmd(0x90|line);break;} //Second row, set the column positioncase
3: {write_cmd(0x88|line);break;} //Third row, set the column positioncase
4: {write_cmd(0x98|line);break;} //Fourth row, set the column position
}
}

void write_xy(uchar row,uchar line,uchar *string) //Display the string at the coordinates of row x and column y
{
uchar lcd_temp; //Define temporary storage variable for display data
set_xy(row,line); //Set the display address to row x and column y
lcd_temp=*string; //Assign the content of string to lcd_temp
while(lcd_temp!=0x00) //Judge the end mark of the string
{
write_dat(lcd_temp); //Write the corresponding content of the string
lcd_temp=*(++string); //Read the next character of the string
}
}

In this way, a function is written. If we want to display "I love electronics" in the third row and second column, we do the following: row x=3, column y=2, the string is "I love electronics", so we write the following code in the main function:

unsigned char string = "I love electronics";

write_xy(3,2,uchar *string);
In this way, we compile the code and download the file to the microcontroller. Then we can see "I love electronics" displayed on the third row and second column of the screen on 12864. The following is an introduction to partial display of pictures on 12864. Before displaying the picture, we need to obtain the binary code of the displayed picture. This can be done with the help of , and then defined in the function (I define it as logo[ ]={ }). The following is the function of partial display of pictures