[9] STM32F4 - CubeMx - Wyświetlacz HD44780 z konwerterem I2C PCF8574

Ten post chciałbym poświęcić na opisanie kontrolera I2C, za pomocą którego można poprzez tą magistralę sterować wyświetlaczem ze sterownikiem HD44780.

Opis konwertera:

Konwerter komunikuje się poprzez magistralę I2C. Na płytce z układem zawarto dodatkowo potencjometr do regulacji kontrastu oraz zworkę pozwalającą na wyłączenie podświetlenia.

Wyprowadzenia z układu są takie same:

W układzie zastosowano obudowę SO16 z następującym rozłożeniem wyprowadzeń:

Cube Mx:

Po standardowym wygenerowaniu projektu, należy uruchomić blok RCC oraz I2C.

Konfigurację I2C nie trzeba zmieniać.

Wygenerowana konfiguracja wygląda następująco:

1. static void MX_I2C1_Init(void)
2. {
3.   hi2c1.Instance = I2C1;
4.   hi2c1.Init.ClockSpeed = 100000;
5.   hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
6.   hi2c1.Init.OwnAddress1 = 0;
7.   hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
8.   hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
9.   hi2c1.Init.OwnAddress2 = 0;
10.   hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
11.   hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
12.   if (HAL_I2C_Init(&hi2c1) != HAL_OK)
13.   {
14.     Error_Handler();
15.   }
16. }

Przygotowanie programu:

Do obsługi wyświetlacza przygotowałem dwa pliki .h oraz .c poniżej przedstawię oba wraz z opisem:

W pierwszej kolejności w pliku .h należy zdefiniować potrzebne wartości do ustawienia odpowiednich pinów w wyświetlaczu oraz definicje wymaganych komend.

1. #define Enable_SET()        LCD_Write_I2C_LCD(portlcd |= 0x04)
2. #define ENABLE_RESET()      LCD_Write_I2C_LCD(portlcd &=~ 0x04)
3. #define RS_SET()            LCD_Write_I2C_LCD(portlcd |= 0x01)
4. #define RS_RESET()          LCD_Write_I2C_LCD(portlcd &=~ 0x01)
5. #define LED_SET()           LCD_Write_I2C_LCD(portlcd |= 0x08)
6. #define WRITE_SET()         LCD_Write_I2C_LCD(portlcd &=~ 0x02)
8. #define HD44780_CLEAR                       0x01
10. #define HD44780_HOME                        0x02
12. #define HD44780_ENTRY_MODE                  0x04
13.     #define HD44780_EM_SHIFT_CURSOR         0
14.     #define HD44780_EM_SHIFT_DISPLAY        1
15.     #define HD44780_EM_DECREMENT            0
16.     #define HD44780_EM_INCREMENT            2
18. #define HD44780_DISPLAY_ONOFF               0x08
19.     #define HD44780_DISPLAY_OFF             0
20.     #define HD44780_DISPLAY_ON              4
21.     #define HD44780_CURSOR_OFF              0
22.     #define HD44780_CURSOR_ON               2
23.     #define HD44780_CURSOR_NOBLINK          0
24.     #define HD44780_CURSOR_BLINK            1
26. #define HD44780_DISPLAY_CURSOR_SHIFT        0x10
27.     #define HD44780_SHIFT_CURSOR            0
28.     #define HD44780_SHIFT_DISPLAY           8
29.     #define HD44780_SHIFT_LEFT              0
30.     #define HD44780_SHIFT_RIGHT             4
32. #define HD44780_FUNCTION_SET                0x20
33.     #define HD44780_FONT5x7                 0
34.     #define HD44780_FONT5x10                4
35.     #define HD44780_ONE_LINE                0
36.     #define HD44780_TWO_LINE                8
37.     #define HD44780_4_BIT                   0
38.     #define HD44780_8_BIT                   16
40. #define HD44780_CGRAM_SET                   0x40
42. #define HD44780_DDRAM_SET                   0x80

Ostatnim elementem w tym pliku są prototypy funkcji:

1. void LCD_Init(void);
2. void LCD_Clear(void);
3. void LCD_Send_Char(char ch);
4. void LCD_Send_String(char* st);
5. void LCD_Set_Position(uint8_t x, uint8_t y);
6. void LCD_Send_Str_Pos(char* st, uint8_t x, uint8_t y);

Teraz czas na plik .c. W pierwszej kolejności funkcje wewnętrzne odpowiedzialne za przesyłanie danych:

Jedna z nich przesyła do wyświetlacza 4 bity, druga natomiast przesyła cały bajt wykorzystując funkcje przesyłające po pół.

1. void Priv_Send_Halfbyte(uint8_t c)
2. {
3.         c<<=4;
4.         ENABLE_SET();
5.         Delay_us(50);
6.        
7.         LCD_Write_I2C_LCD(portlcd|c);
8.        
9.         ENABLE_RESET();
10.         Delay_us(50);
11. }
13. void Priv_Send_Byte(uint8_t c, uint8_t mode)
14. {
15.         uint8_t hc=0;
16.        
17.         if (mode==0) { RS_RESET(); }
18.         else         { RS_SET();   }
19.         hc=c>>4;
20.        
21.         Priv_Send_Halfbyte(hc);
22.         Priv_Send_Halfbyte(c);
23. }

Następna w kolejności będzie funkcja przesyłające dane za pomocą I2C do LCD:

1. uint8_t bufer_i2c[1] = {0};
3. void LCD_Write_I2C_LCD(uint8_t to_send)
4. {
5.     bufer_i2c[0] = to_send;
6.     HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)0x4E, bufer_i2c, sizeof(bufer_i2c), 1000);
7. }

Realizuje się ją za pomocą funkcji wbudowanej w biblioteki hala(definicja w pliku stm32f4xx_hal_i2c.h). Wysyła ona dane wybraną magistralą I2C do adresu urządzenia, (0x4E). Przesyłany jest jeden bajt danych. Ostatni parametr to tzw. timeout, który określa ile czasu funkcja będzie przesyłała dane.

Funkcja odpowiedzialna za włączenie wyświetlacza:

1. void LCD_Init(void)
2. {
3.     uint8_t i=0;
5.     //Wybranie trybu czterobitowego dane wysylane cztery razy
6.     HAL_Delay(100);
7.     for(i=0;i<3;i++)
8.     {
9.         Priv_Send_Halfbyte(0x03);
10.         HAL_Delay(45);
11.     }
13.     //Wlaczenie trybu czterobitowego
14.     Priv_Send_Halfbyte(0x02);
15.     HAL_Delay(100);
17.     Priv_Send_Byte(HD44780_FUNCTION_SET | HD44780_FONT5x7 | HD44780_TWO_LINE | HD44780_4_BIT,0);
18.     HAL_Delay(1);
20.     Priv_Send_Byte(HD44780_DISPLAY_ONOFF | HD44780_DISPLAY_OFF,0);
21.     HAL_Delay(1);
23.     Priv_Send_Byte(HD44780_ENTRY_MODE | HD44780_EM_SHIFT_CURSOR | HD44780_EM_INCREMENT,0);
24.     HAL_Delay(1);
26.     Priv_Send_Byte(HD44780_DISPLAY_ONOFF | HD44780_DISPLAY_ON | HD44780_CURSOR_OFF | HD44780_CURSOR_NOBLINK,0);
27.     HAL_Delay(1);
29.     LED_SET();
30.     WRITE_SET();
32.     LCD_Clear();
33. }

Poniżej funkcje odpowiedzialne za czyszczenie wyświetlacza,  przesyłania pojedynczego znaku, całego ciągu znaków bądź tekstu wraz z pozycją startową jego umieszczenia.

1. void LCD_Clear(void)
2. {
3.     Priv_Send_Byte(HD44780_CLEAR, 0);
4.     HAL_Delay(1000);
5. }
7. void LCD_Send_Char(char ch)
8. {
9.     Priv_Send_Byte(ch, 1);
10. }
12. void LCD_String(char* str)
13. {
14.     uint8_t i=0;
16.     while(str[i] != 0)
17.     {
18.         Priv_Send_Byte(str[i],1);
19.         i++;
20.     }
21. }
23. void LCD_Send_Str_Pos(char* st, uint8_t x, uint8_t y)
24. {
25.     LCD_Set_Position(x, y);
26.     LCD_Send_String(st);
27. }

Kolejnym elementem jest funkcja ustawiająca pozycję wyświetlacza dla dwóch wierszy:

1. void LCD_Set_Position(uint8_t x, uint8_t y)
2. {
3.     switch(y)
4.     {
5.        case 0:
6.             Priv_Send_Byte(x|0x80,0);
7.             HAL_Delay(1);
8.             break;
9.        case 1:
10.             Priv_Send_Byte((0x40+x)|0x80,0);
11.             HAL_Delay(1);
12.             break;
13.     }
14. }

W przypadku wykorzystywania czterech linii funkcje należy zmodyfikować do następującej postaci:

1. void LCD_Set_Position(uint8_t x, uint8_t y)
2. {
3.     switch(y)
4.     {
5.        case 0:
6.             Priv_Send_Byte(x|0x80,0);
7.             HAL_Delay(1);
8.             break;
9.        case 1:
10.             Priv_Send_Byte((0x40+x)|0x80,0);
11.             HAL_Delay(1);
12.             break;
13.        case 2:
14.             Priv_Send_Byte((0x14+x)|0x80,0);
15.             HAL_Delay(1);
16.             break;
17.        case 3:
18.             Priv_Send_Byte((0x54+x)|0x80,0);
19.             HAL_Delay(1);
20.             break;
21.     }
22. }

Dalszym elementem jest włączenie biblioteki, poprzez wywołanie funkcji LCD_Init. Następnie można wysyłać dane na wyświetlacz lub poprzez zwykłe wpisanie ciągu znaków w cudzysłowie, bądź za pomocą funkcje sprintf.

Cały projekt można pobrać z dysku Google pod tym linkiem.