STM32 and LCD. Working with a graphic display

At the request of the workers, and also my promises, I decided to describe the work with the iconic 16x2 LCD in the CodeVisionAVR environment. Let's start with a description of the LCD itself. The alphanumeric LCD display with built-in Hitachi HD44780 chip can display characters in one, two or four terms of 8, 16, 20 or 40 characters each. In this article I will consider LCD 16x2 (16 characters, 2 lines). This display for physical connection to the MK has 16 pins (the location of the pins depends on the manufacturer). Let's look at these findings. Without further ado, I stole the sign in MELT. In principle, it is suitable for any LCD.
Well, I think there is no need to explain why this or that pin is needed. Everything is written there in Russian. But there are a few small but. 1) LCD displays can be produced in two versions: 5 volts or 3.3. 2) A current-limiting resistor is not always installed in the power circuit. Look carefully, there may just be a jumper. (I burned out the backlight on two displays this way.) 3) Circuit for connecting a resistor to adjust the contrast.
So, well, now how to connect this miracle to the MK. We will work with ATmega8 and quartz at 4 MHz. Here is the actual diagram.
As you can see, there is nothing complicated. The first three digits of the port D serve for control, and the last four for data. It is also possible to work with these displays on an 8-bit bus, but I think giving away an extra 4 legs is a waste. Therefore, we will work on a 4-bit bus. We've figured out the circuit, now let's look at the software part. To initialize the display and switch it to 4-bit mode, you need to run several commands. But before that, I want to explain how control bits work. The RS bit is responsible for what the LCD will receive. If RS = 0, then we send the command, and if 1 then data. If bit RW=0, then we write to the LCD, and if 1 , then we read. Bit E just a strobe. That is, as soon as we want to enter a command or data, then after we have set all the bits on the legs we simply set them to 1 bit E, and then we drop it again 0 . 1 - Turn on the power 2 - Pause for at least 20 ms 3 - Command for 4 bits. bus 4 - Maintain a pause of at least 40 µs 5 - Command for 4 bits. tires (RS=0), (RW=0), (D7=0), (D6=0), (D5=1), (D4=1) 6 - Maintain a pause of at least 40 µs 7 - Command for 4 bits. tires (RS=0), (RW=0), (D7=0), (D6=0), (D5=1), (D4=1) 8 - Maintain a pause of at least 40 µs 9 - Command for 4 bits. tires (RS=0), (RW=0), (D7=0), (D6=0), (D5=1), (D4=0) 10 - Maintain a pause of at least 40 µs 11 - Set parameters (RS=0), (RW=0), (D7=0), (D6=0), (D5=1),(D4=0) (RS=0), (RW=0), (D7= 1), (D6=0), (D5=0), (D4=0) 12 - Turn off the display (RS=0), (RW=0), (D7=0), (D6=0), (D5=0),(D4=0) (RS=0), (RW=0), (D7= 0), (D6=0), (D5=1), (D4=0) 13 - Clear the screen (RS=0), (RW=0), (D7=0), (D6=0), (D5=0),(D4=0) (RS=0), (RW=0), (D7= 0), (D6=0), (D5=0),(D4=1) 14 - Data input mode (RS=0), (RW=0), (D7=0), (D6=0), (D5=0),(D4=0) (RS=0), (RW=0), (D7= 0), (D6=1), (D5=1),(D4=0) Oh how. Now after this gobbledygook our display is ready to receive data. What's next. And then let's look at the LCD commands. To transmit commands/data to the LCD via a 4-bit bus, two passes are required. We transmit the most significant 4 bytes first, and the lowest 4 bytes are transmitted second. From now on I will write all the commands in pairs. The command to clear the indicator and place the cursor in the upper left corner. RS=0, RW=0, D4=0, D5=0, D6=0, D7=0 (E=1 then 0) RS=0, RW=0, D4=0, D5=0, D6=0, D7=1 (E=1 then 0) Command to move the cursor to the left position. (X means who cares what the value is) RS=0, RW=0, D4=0, D5=0, D6=0, D7=0 (E=1 then 0) RS=0, RW=0, D4=0, D5=0, D6=1, D7=X (E=1 then 0) The command sets the direction of cursor shift (ID=0/1 left/right). Also display shift resolution (SH=1) when writing to DDRAM. RS=0, RW=0, D4=0, D5=0, D6=0, D7=0 (E=1 then 0) RS=0, RW=0, D4=0, D5=1, D6=ID, D7=SH (E=1 then 0) Command to turn on the display (D=1) and select the cursor (A, B). A=0, B=0 There is no cursor, nothing blinks A=0, B=1 There is no cursor, the entire symbol blinks A=1, B=0 Cursor in the form of an underline, does not blink A=1, B=1 Cursor appears as an underline and blinks RS=0, RW=0, D4=0, D5=0, D6=0, D7=0 (E=1 then 0) RS=0, RW=0, D4=1, D5=D, D6=A, D7=B (E=1 then 0) Display/cursor shift command (SC=0/1 cursor/display RL=0/1 left/right). RS=0, RW=0, D4=0, D5=0, D6=0, D7=1 (E=1 then 0) RS=0, RW=0, D4=SC, D5=RL, D6=X, D7=X (E=1 then 0) Command for setting the bus width (DL=0/1 4/8 bits) As well as character generator pages P. RS=0, RW=0, D4=0, D5=0, D6=1, D7=DL (E=1 then 0) RS=0, RW=0, D4=1, D5=0, D6=P, D7=0 (E=1 then 0) The command for setting the address of the next operation with placing the cursor there and selecting the CGRAM area (Your own invented characters). RS=0, RW=0, D4=0, D5=1, D6=ACG, D7=ACG (E=1 then 0) RS=0, RW=0, D4=ACG, D5=ACG, D6=ACG, D7=ACG (E=1 then 0) Command for setting the address of the subsequent operation and selecting the DDRAM memory area (Character Generator). RS=0, RW=0, D4=0, D5=1, D6=ADD, D7=ADD (E=1 then 0) RS=0, RW=0, D4=ADD, D5=ADD, D6=ADD, D7=ADD (E=1 then 0) Command Write data to the current area. RS=1, RW=0, D4=DATA, D5=DATA, D6=DATA, D7=DATA (E=1 then 0) RS=1, RW=0, D4=DATA, D5=DATA, D6=DATA, D7=DATA (E=1 then 0) Command Read data into the current area. RS=1, RW=1, D4=DATA, D5=DATA, D6=DATA, D7=DATA (E=1 then 0) RS=1, RW=1, D4=DATA, D5=DATA, D6=DATA, D7=DATA (E=1 then 0) That's actually all the commands. There is also a command to read the busy flag, but I don’t use it, I just wait at least 40 µs between each command. That's all. Now, after reading this treatise, drink a cup of tea or coffee and forget about all this. Since all this crap is taken over by functions from the CodeVisionAVR library. We create a new project as already described. For those who are not in the know, go here, the rest go to the tab in the code generator LCD and choose PORTD. What did we do with it? First, we told the program that we wanted to work with the LCD display (by selecting the tab LCD). Then we said that we would connect it to the port D. The drop-down list below allows you to select the number of characters per line. Since the default is 16 , and we want to work with a 16x2 LCD, then we don’t need to change anything. Below, as a hint, the port legs for correctly connecting the LCD to the MK are painted. That's it, save the project and look at the newly generated code. The first thing you need to pay attention to is the piece of code after the preprocessor directive #include Here's this one: // Alphanumeric LCD Module functions #asm .equ __lcd_port=0x12 ;PORTD #endasm #include > Let's look at it line by line. The first line is a comment that says that we have included a header file with functions for working with a symbolic LCD. On the second line we open a block for entering assembler commands. The next line assigns the port to which the LCD is connected. Team .equ in assembler it does the same thing as the command #include in C. If you accidentally selected the wrong port in the code generator, you can always change it in this line. The port number can always be found in the MK initialization file. It is always connected in the very first line. In our case it is mega8.h. The next line closes the assembly code block. And the last line just connects everything necessary to work with the LCD. Now let's go over the main features. The first function that needs to be called before you start torturing the LCD is, of course, the display initialization function. She looks like this: void lcd_init(unsigned char lcd_columns) This function initializes the display, and the parameter passed must be the number of characters in the line. We scroll our program to the very bottom and before the main loop we see two lines with the following content: // LCD module initialization lcd_init(16); These are the same 16 lines that the program selected from the list of the code generator and stuffed as an argument into the function. Here, too, if in your fright you forgot that your LCD has 8 or 20 characters per line, then simply change the value of the argument in this function. void lcd_gotoxy(unsigned char x, unsigned char y) This function, as its name suggests, moves the cursor to the position x, y. Here x- this is a letter. From left to right from 0 to 15/19/39 (depends on the number of letters in the line). A y is a string. Top to bottom from 0 to 0/1/3 (depends on the number of lines) . void lcd_putchar(char c) This function outputs one character at the current position. Example: lcd_putchar("A") or lcd_putchar(0x41) which will give the same result. That is, the parameter can be either a symbol or its code. lcd_gotoxy(0,0); lcd_putchar("A"); lcd_gotoxy(0,1); lcd_putchar(0x41); I think comments are unnecessary here, let's look at the result.
Next function. void lcd_puts(char *str) This function prints a string located in SRAM starting from the current position. Example: lcd_gotoxy(0,0); lcd_puts("ROW"); We see:
Next function. void lcd_putsf(char *str) This function prints the string located in FLASH starting from the current position. Example: lcd_gotoxy(0,0); lcd_putsf("ROW"); We see:
Well, the “Eraser” function brings this whole mess to a close. void lcd_clesr(void) By calling this function, you will erase everything that is on the display, and the cursor will move to the far left position of the top line. This is how, to begin with, you can display words and numbers on the LCD display using ready-made functions. Now let's talk about how to display the value of variables. For these purposes we will need another library. Well, those who programmed in C on a PC should know about it. It's called stdio.h We rise to the very top of the program and after the preprocessor directive #include adding #include As a result, our code will look like this. // Alphanumeric LCD Module functions#asm .equ __lcd_port=0x12 ;PORTD #endasm #include #include Now let's get acquainted with the function that formats text. void printf(char flash *fmtstr [,arg1, arg2, ...]) How it works. IN char flash *fmtstr the format of the output value is specified, and the arguments arg1, arg2, ... variable name. Example. unsigned char temp = 123; printf("temp = %05d\n", temp); What does this abra-kadabra mean? The first line creates a variable and assigns a value to it. Everything is clear here, but here’s what the second one does. Everything is in order. The entry is displayed first temp =, then 00123 . Why is it displayed? 00123 . And because we have a condition %05d\n which says: 1) % - we will format the values ​​of the first argument 2) 0 - we will output n characters, empty ones will be filled with zeros 3) 5 - display 5 characters, if the number is less than 5 characters, then fill in the blanks with zeros. This is indicated in point 2. The number will be aligned to the right. 4) d- display the number in decimal format. 5) \n- Forces you to move to another line after printing a character. Next function. void sprintf(char flash, char flash *fmtstr [,arg1, arg2, ...]) This is the function that is most interesting to us. It formats the string and writes it to an array. Afterwards we can safely display the array on the screen. How it works. unsigned char temp = 123; unsigned char string; sprintf(string, "temp = %05d\n", temp); lcd_puts(string); Here's what it looks like live.
So we learned how to display formatted text on the LCD. Next, I’ll briefly go over the types of transformation. i d- To output a signed decimal integer u- To output unsigned decimal integer e -d.d e-d E- To display real floating point data -d.d E-d f- To display real floating point data -d.d x- For output in hexadecimal in small letters X- For output in hexadecimal in capital letters c- For output to symbol If you write %-05d then the sign "-" will force alignment to the left, and blanks will not be filled with zeros. If you try to print a floating point number, you will be very surprised. The number will not be printed. It's an ambush)) The problem lies in the compiler settings. In order for the compiler to begin to understand the format float you need to tweak it a little. For this we go Project->Configure and go to the tab C Compiler. In property (s)printf Features: choose float, width, precision. That's all. Try it, experiment. If you have any questions, write on the forum. Good luck!

• The FC-113 module is based on the PCF8574T chip, which is an 8-bit shift register - an input-output “expander” for the I2C serial bus. In the figure, the microcircuit is designated DD1.
• R1 is a trim resistor for adjusting the contrast of the LCD display.
• Jumper J1 is used to turn on the display backlight.
• Pins 1…16 are used to connect the module to the LCD display pins.
• Contact pads A1...A3 are needed to change the I2C address of the device. By soldering the appropriate jumpers, you can change the device address. The table shows the correspondence of addresses and jumpers: “0” corresponds to an open circuit, “1” to an installed jumper. By default, all 3 jumpers are open and the device address 0x27.

2 Connection diagram for LCD display to Arduino via I2C protocol

The module is connected to Arduino in a standard way for the I2C bus: the SDA pin of the module is connected to analog port A4, the SCL pin is connected to analog port A5 of Arduino. The module is powered by +5 V from Arduino. The module itself is connected by pins 1…16 to the corresponding pins 1…16 on the LCD display.

3 Library for work via I2C protocol

Now we need a library to work with LCD via the I2C interface. You can use, for example, this one (link in the line "Download Sample code and library").

Downloaded archive LiquidCrystal_I2Cv1-1.rar unzip to a folder \libraries\, which is located in the Arduino IDE directory.

The library supports a set of standard functions for LCD screens:

4 Sketch for text output to LCD screen via I2C bus

Let's open the sample: File Samples LiquidCrystal_I2C CustomChars and we'll change it up a little. We will display a message at the end of which there will be a blinking symbol. The comments to the code comment on all the nuances of the sketch.

#include // include the Wire library #include // connect the LCD library #define printByte(args) write(args); // uint8_t heart = (0x0,0xa,0x1f,0x1f,0xe,0x4,0x0); // bit mask of the “heart” symbol LiquidCrystal_I2C lcd(0x27, 16, 2); // Set address 0x27 for 16x2 LCD display void setup() ( lcd.init(); // initializing the LCD display lcd.backlight(); // turn on the display backlight lcd.createChar(3, heart); // create a “heart” symbol in memory cell 3 lcd.home(); // place the cursor in the upper left corner, at position (0,0) lcd.!"); // print a line of text lcd.setCursor(0, 1); // move the cursor to line 2, character 1 lcd.print( " i "); // print the message on line 2 lcd.printByte(3); // print the "heart" symbol located in the 3rd cell lcd.print(" Arduino "); } void loop() (// flashing the last character lcd.setCursor(13, 1); // move the cursor to line 2, character 1 lcd.print("\t"); delay(500); lcd.setCursor(13, 1); // move the cursor to line 2, character 1 lcd.print(" "); delay(500); }

By the way, the characters written by the command lcd.createChar();, remain in the display memory even after turning off the power, because written to display ROM 1602.

5 Create your own symbols for LCD display

Let's take a closer look at the issue of creating your own symbols for LCD screens. Each character on the screen consists of 35 dots: 5 wide and 7 high (+1 reserve line for underlining). In line 6 of the above sketch we define an array of 7 numbers: (0x0, 0xa, 0x1f, 0x1f, 0xe, 0x4, 0x0). Convert hexadecimal numbers to binary: {00000, 01010, 11111, 11111, 01110, 00100, 00000} . These numbers are nothing more than bit masks for each of the 7 lines of the symbol, where "0" denotes a light point and "1" a dark point. For example, a heart symbol specified as a bitmask will appear on the screen as shown in the figure.

6 LCD screen control via I2C bus

Let's upload the sketch to Arduino. The inscription we specified with a blinking cursor at the end will appear on the screen.

7 What's behind I2C bus

As a bonus, let's look at the timing diagram for displaying the Latin characters "A", "B" and "C" on the LCD display. These characters are stored in the display ROM and are displayed on the screen simply by transmitting their addresses to the display. The diagram is taken from the RS, RW, E, D4, D5, D6 and D7 pins of the display, i.e. already after the FC-113 “I2C parallel bus” converter. We can say that we are diving a little deeper into the hardware.

The diagram shows that the characters that are in the display ROM (see p. 11 of the datasheet, link below) are transmitted in two nibbles, the first of which determines the table column number, and the second - the row number. In this case, the data is “latched” at the edge of the signal on the line E(Enable), and the line R.S.(Register select) is in a logical one state, which means data is being transferred. A low state on the RS line means instructions are being sent, which is what we see before each character is transmitted. In this case, the instruction code for carriage return to position (0, 0) of the LCD display is transmitted, which can also be found out by studying the technical description of the display.

And one more example. This timing diagram shows the output of the Heart symbol on the LCD display.

Again, the first two impulses Enable comply with instructions Home()(0000 0010 2) - return the carriage to position (0; 0), and the second two - output to the LCD display stored in memory cell 3 10 (0000 0011 2) the “Heart” symbol (instruction lcd.createChar(3, heart); sketch).

Reader of our blog Mikhail ( mishadesh) created an excellent library for working with LCD and suggested writing an article to demonstrate its capabilities. Actually, this is exactly what we will be talking about today 😉 Let’s look at what functions are implemented, and at the end of the article there will be an example for working with the display.

As usual, let's start with a discussion of hardware... But there’s really nothing to talk about. As in the first article on working with displays (), we will use a development board Mini STM32. Actually, connecting the display, the basic commands for recording data, the sequence of instructions for initialization - it’s all there =) Therefore, now let’s go straight to discussing the library for working with graphic displays.

Here is a complete list of functions with explanations:

The next function, as its name suggests, changes the screen orientation. Two screen positions are possible, respectively, two possible parameter values orientation:

• Orientation_Portrait
• Orientation_Album

The function draws a symbol on the graphic display, positioning it according to the coordinates passed to the function, and also setting its color. The character style matches the font defined in the file font.c(the file is included in the library).

From function LCD_DrawChar() The following function flows smoothly:

It’s clear here without further ado 😉 The function prints on LCD line of text. The basis for this function is the previous one - LCD_DrawChar().

In addition to symbols and text, of course, you need to be able to draw basic graphic primitives, such as a line or a circle. To do this, the following has been implemented:

To draw a line, you need to pass the coordinates of the starting point, the coordinates of the end point, and the desired color to the function. For a rectangle - the coordinates of the upper left corner and the coordinates of the lower right corner (!). Last parameter filled– determines whether the shape should be filled. One means yes, the figure will be painted with the selected color, zero means only the outline of the figure will be drawn. This is clear) All that remains is the circle - the function DrawEllipse(). Here, instead of the coordinates of the start and end (upper/lower corners), we pass the center of the circle and the radius as arguments.

And finally, one more function:

The function allows you to fill the screen with a solid color.

All listed functions are implemented in the file GUI_DRV.c.

In addition to them, the library includes functions for writing data to the display ( LCD_DRIVER.c) as well as the already mentioned fonts ( font.c). As you can see, everything is clearly sorted into different files, so in principle everything is very clear, so let's move on to a practical example!

Let's find out! Let's go to the file main.c... I will not give the complete code for the functions for initializing the peripherals and display; all this can be viewed directly in the file, or in the previous article, the link to which was at the beginning of this article 😉 Function main():

We start with initialization, paint the screen white and set the screen orientation to landscape. And now we move on to drawing graphics)

We display a line on the screen, as well as two rectangles and a circle. The result is clear:

Obviously everything works great 😉

So, that’s where we end for today, many thanks to Mikhail for the work done and the materials provided. Here are the contacts of the library author:

Skype - mishadesh

Mail – [email protected]

That's all, thank you for your attention, see you soon!