Som Labs - IMx6 ULL - Debian - Obsługa I2C na przykładzie wyświetlacza 2x16

W tym poście chciałbym przedstawić obsługę interfejsu I2C na przykładzie pamięci EEPROM oraz wyświetlacza 2x16.

[Źródło: https://somlabs.com/product/visionsom-6ull/]

Przykładowa obsługa I2C umieszczona na stronie producenta (przykład dotyczy pamięci EEPROM):

https://wiki.somlabs.com/index.php/How_to_use_VisionSOM-6ULL_I2C_interface_in_command_line_and_C_programs

I2C:

W przypadku gdy sterownik jest uruchomiony można to sprawdzić przez wpisanie komendy:

1. ls /sys/class/i2c-adapter

Domyślnie I2C-1 powinien być uruchomiony. W celu obsługi innego interfejsu należy przełożyć zmodyfikować device tree o następujące wpisy:

1. &i2c1 {
2.         clock_frequency = <100000>;
3.         pinctrl-names = "default";
4.         pinctrl-0 = <&pinctrl_i2c1>;
5.         status = "okay";
6. };
8. &i2c2 {
9.         clock_frequency = <100000>;
10.         pinctrl-names = "default";
11.         pinctrl-0 = <&pinctrl_i2c2>;
12.         status = "okay";
13. };
15. &iomuxc {
16.         pinctrl-names = "default";
17.         pinctrl-0 = <&pinctrl_hog_1>;
18.         imx6ul-evk {
20.                 ...
21.                 ...
23.                pinctrl_i2c1: i2c1grp {
24.                         fsl,pins = <
25.                                 MX6UL_PAD_UART4_TX_DATA__I2C2_SCL 0x4001b8b0
26.                                 MX6UL_PAD_UART4_RX_DATA__I2C2_SDA 0x4001b8b0
27.                         >;
28.                 }
29.                
30.                 pinctrl_i2c2: i2c2grp {
31.                         fsl,pins = <
32.                                 MX6UL_PAD_UART5_TX_DATA__I2C2_SCL 0x4001b8b0
33.                                 MX6UL_PAD_UART5_RX_DATA__I2C2_SDA 0x4001b8b0
34.                         >;
35.                 }
36.                
37.                 ...
38.                 ...
39.                
40. };

Aby umożliwić dostęp z poziomu interfejsu /dev należy zainstalować następujące biblioteki:

1. apt install libi2c-dev i2c-tools

W celu ładowania modułu i2c-dev po starcie systemu należy go dopisać w pliku /etc/modules:

1. sudo nano /etc/modules

Następnie w celu upewnienia się że instalacja przebiegła poprawnie można wyświetlić zawartość katalogu dev:

Do wyszukania adresu urządzenia można wykorzystać programu i2cdetect. Jako parametr podawany jest numer interfejsu I2C:

W moim przypadku adres I2C wynosi 0x27(sterownik PCF8574T). Inne dostępne sterowniki powinny się przedstawiać w następujący sposób:

• PCF8574 - 0x20;
• PCF8574T - 0x27;
• PCF8574A - 0x38;
• PCF8574AT - 0x3F;

W przypadku gdy zamiast podanego adresu będzie wyświetlony napis UU. Oznacza to, że dane urządzenie jest wykorzystywane przez jakiś sterownik.

Podłączenie I2C:

Podłączenie do linii I2C-1 jest dostępne z złącz RPI:

• Pin 1 - 3V3
• Pin 3 - SDA
• Pin 5 - SCL
• Pin 6 - GND

Poniżej fragment schematu udostępnionego przez producenta (link):

Te same piny wyprowadzone są również na złącze Arduino. Różnica polega na tym, że linie podłączone są tam przez konwerter poziomów logicznych z 5V na 3V3(TXS0108EPWR). Linie I2C na złączu żółtym 10 pinowym:

Obsługa wyświetlacza 2x16:

Do obsługi wyświetlacza wykorzystałem zmodyfikowaną bibliotekę pod układ STM32, która została umieszczona wcześniej na tym blogu.

Na samym początku uruchomienie I2C:

1. #define I2C_FILE_NAME "/dev/i2c-1"
2. #define I2C_DISP_ADDRESS 0x27
4. int Open_I2C(const char* devPath, uint8_t devAddress) {
5.     int device;
7.     if((device = open(devPath, O_RDWR)) < 0 ) {
8.        return (-1);
9.     }
11.     if((ioctl(device, I2C_SLAVE, devAddress & 0x7F)) < 0 ) {
12.        return (-2);
13.     }
15.     return device;
16. }

Na samym początku należy uruchomić linię dla odczytu i zapisu danych (O_RDWR). Otwarcie zwraca deskryptor który zostaje użyty do konfiguracji. W przypadku zwrócenia wartości ujemnej nastąpił błąd uruchamiania linii. Mógł być spowodowany błędną nazwą pliku do otwarcia lub niewystarczającymi uprawnieniami dostępu do pliku. Po udanym otwarciu linii należy rozpocząć komunikację z urządzeniem. Wykonywane jest przez przesłanie do podanego urządzenia adresu wraz z bitem zapisu/odczytu (bit 0 odczyt, bit 1 zapis).

Zapis danych:

1. static uint8_t Write_I2C(int device, uint8_t value) {
2.     int status;
3.     uint8_t buffer[2] = {value, 0x00};
5.     if((status = write(device, buffer, 1))<0 ){
6.         printf("Write Error I2C %d\n", status);
7.         return 1;
8.     }
9.     usleep(2);
10.     return 0;
11. }

Zamknięcie I2C:

1. void Close_I2C(int device) {
2.     close(device);
3. }

Poniżej całe pliki z biblioteką oraz plik main:

Plik lcd2_16.c:

1. #include <stdio.h>
2. #include <linux/i2c-dev.h>
3. #include <fcntl.h>
4. #include <stdlib.h>
5. #include <unistd.h>
6. #include <sys/ioctl.h>
7. #include <string.h>
8. #include "lcd2_16.h"
9. //---------------------------------------------------------------
10. /* Global variables */
11. uint8_t portlcd=0;
12. //---------------------------------------------------------------
13. /* Static functions declarations */
14. static void Priv_Send_Halfbyte(int device, uint8_t c);
15. static void Priv_Send_Byte(int device, uint8_t c, uint8_t mode);
16. static uint8_t Write_I2C(int device, uint8_t value);
17. //---------------------------------------------------------------
18. /* I2C Interfejs functions */
19. int Open_I2C(const char* devPath, uint8_t devAddress) {
20.     int device;
21.     if((device = open(devPath, O_RDWR)) < 0 ) {
22.        return (-1);
23.     }
25.     if((ioctl(device, I2C_SLAVE, devAddress & 0x7F)) < 0 ) {
26.        return (-2);
27.     }
28.     return device;
29. }
31. void Close_I2C(int device) {
32.     close(device);
33. }
35. static uint8_t Write_I2C(int device, uint8_t value) {
36.     int status;
37.     uint8_t buffer[2] = {value, 0x00};
39.     if((status = write(device, buffer, 1))<0 ){
40.         printf("Write Error I2C %d\n", status);
41.         return 1;
42.     }
43.     usleep(2);
44.     return 0;
45. }
46. //-------------------------------------------------------------
47. static void Priv_Send_Halfbyte(int device, uint8_t c)
48. {
49.     c<<=4;
50.     ENABLE_SET(device);
51.     usleep(50);
53.     Write_I2C(device, portlcd|c);
54.     ENABLE_RESET(device);
56.     usleep(50);
57. }
59. static void Priv_Send_Byte(int device, uint8_t c, uint8_t mode)
60. {
61.     uint8_t hc=0;
63.     if (mode==0)
64.     {
65.        RS_RESET(device);
66.     }
67.     else
68.     {
69.        RS_SET(device);
70.     }
71.     hc=c>>4;
73.     Priv_Send_Halfbyte(device, hc);
74.     Priv_Send_Halfbyte(device, c);
75. }
76. //-------------------------------------------------------------
77. void LCD_Initial(int device){
78.     for(uint8_t i=0;i<3;i++)
79.     {
80.         Priv_Send_Halfbyte(device, 0x03);
81.         usleep(45000);
82.     }
84.     //Wlaczenie trybu czterobitowego
85.     Priv_Send_Halfbyte(device, 0x02);
86.     usleep(100000);
88.     Priv_Send_Byte(device, HD44780_FUNCTION_SET | HD44780_FONT5_7 | HD44780_TWO$
89.     usleep(1000);
91.     Priv_Send_Byte(device, HD44780_DISPLAY_ONOFF | HD44780_DISPLAY_OFF,0);
92.     usleep(1000);
94.     Priv_Send_Byte(device, HD44780_ENTRY_MODE | HD44780_EM_SHIFT_CURSOR | HD447$
95.     usleep(1000);
97.     LED_SET(device);
98.     WRITE_SET(device);
100.     LCD_Clear(device);
101. }
103. void LCD_Clear(int device)
104. {
105.     Priv_Send_Byte(device, 0x01,0);
106.     usleep(1000000);
107. }
109. void LCD_Send_Char(int device, char ch)
110. {
111.     Priv_Send_Byte(device, ch,1);
112. }
114. void LCD_Send_String(int device, char* st
115. {
116.     uint8_t i=0;
118.     while(st[i] != 0)
119.     {
120.        Priv_Send_Byte(device, st[i],1);
121.        i++;
122.     }
123. }
125. void LCD_Send_Str_Pos(int device, char* st, uint8_t x, uint8_t y)
126. {
127.     LCD_Set_Position(device, x,y);
128.     LCD_Send_String(device, st);
129. }
131. void LCD_Set_Position(int device, uint8_t x, uint8_t y)
132. {
133.     switch(y)
134.     {
135.       case 0:
136.           Priv_Send_Byte(device, x|0x80, 0);
137.           usleep(1000);
138.       break;
139.       case 1:
140.           Priv_Send_Byte(device, (0x40+x)|0x80, 0);
141.           usleep(1000);
142.       break;
143.     }
144. }

Plik lcd2_16.h:

1. #ifndef LCD2_16_H_
2. #define LCD2_16_H_
4. #include <stdio.h>
5. #include <stdint.h>
7. #define I2C_FILE_NAME "/dev/i2c-1"
8. #define I2C_DISP_ADDRESS 0x27
10. #define ENABLE_SET(x) Write_I2C(x, portlcd |= 0x04)
11. #define ENABLE_RESET(x) Write_I2C(x, portlcd &=~ 0x04)
12. #define RS_SET(x) Write_I2C(x, portlcd |= 0x01)
13. #define RS_RESET(x) Write_I2C(x, portlcd &=~ 0x01)
14. #define LED_SET(x) Write_I2C(x, portlcd |= 0x08)
15. #define WRITE_SET(x) Write_I2C(x, portlcd &=~ 0x02)
17. #define HD44780_CLEAR 0x01
18. #define HD44780_HOME 0x02
20. #define HD44780_ENTRY_MODE 0x04
21. #define HD44780_EM_SHIFT_CURSOR 0
22. #define HD44780_EM_SHIFT_DISPLAY 1
23. #define HD44780_EM_DECREMENT 0
24. #define HD44780_EM_INCREMENT 2
26. #define HD44780_DISPLAY_ONOFF 0x08
27. #define HD44780_DISPLAY_OFF 0
28. #define HD44780_DISPLAY_ON 4
29. #define HD44780_CURSOR_OFF 0
30. #define HD44780_CURSOR_ON 2
31. #define HD44780_CURSOR_NOBLINK 0
32. #define HD44780_CURSOR_BLINK 1
34. #define HD44780_DISPLAY_CURSOR_SHIFT 0x10
35. #define HD44780_SHIFT_CURSOR 0
36. #define HD44780_SHIFT_DISPLAY 8
37. #define HD44780_SHIFT_LEFT 0
38. #define HD44780_SHIFT_RIGHT 4
39. #define HD44780_FUNCTION_SET 0x20
40. #define HD44780_FONT5_7 0
41. #define HD44780_FONT5_10 4
42. #define HD44780_ONE_LINE 0
43. #define HD44780_TWO_LINE 8
44. #define HD44780_4_BIT 0
45. #define HD44780_8_BIT 16
46. #define HD44780_CGRAM_SET 0x40
47. #define HD44780_DDRAM_SET 0x80
49. /* I2C */
50. int Open_I2C(const char* devPath, uint8_t devAddress);
51. void Close_I2C(int device);
53. /* DISPLAY */
54. void LCD_Initial(int device);
55. void LCD_Clear(int device);
56. void LCD_Send_Char(int device, char ch);
57. void LCD_Send_String (int device, char* st);
58. void LCD_Set_Position(int device, uint8_t x, uint8_t y);
59. void LCD_Send_Str_Pos(int device, char* st, uint8_t x, uint8_t y);
61. #endif /* LCD2_16_H_ */

Plik main.c:

1. #include <stdio.h>
2. #include <string.h>
3. #include <linux/fb.h>
4. #include "lcd2_16.h"
6. int main(){
7.     int i2c_dev = Open_I2C(I2C_FILE_NAME, I2C_DISP_ADDRESS);
9.     if(i2c_dev <0){
10.        printf("Blad I2C: %d\n", i2c_dev);
11.        return 1;
12.     }
14.     else{
15.       printf("I2C dziala: %d\n", i2c_dev);
16.     }
18.     LCD_Initial(i2c_dev);
19.     LCD_Send_Str_Pos(i2c_dev, "linia1",0,0);
20.     LCD_Send_Str_Pos(i2c_dev, "linia2",0,1);
21.     Close_I2C(i2c_dev);
23.     return 0;
24. }

W celu wykonania kompilacji programu należy w konsoli wpisać:

1. gcc lcd2_16.c main.c -o main

W przypadku korzystania z własnych bibliotek należy je uwzględnić w kompilacji.

Teraz wystarczy wywołać przygotowany program przez wprowadzenie w konsoli:

1. ./main