Introduction to GPIO programming basics for Allwinner module device development

aleksib

Introduction to GPIO programming basics for Allwinner module device development [Copy link]

 

## 9.1 Introduction to GPIO Programming Basics GPIO (General-Purpose IO Ports) is a general-purpose IO interface. The use of GPIO is relatively simple, and it is mainly divided into two functions: input and output. GPIO is mainly used to control some simple devices. In the case of input GPIO, we can connect the IO to external buttons or sensors to detect external states. When used as an output, we can control the operation of external devices by outputting high and low levels.Due to the variety of GPIO functions, we need to set the pin to GPIO first. After setting it to GPIO, we need to set the direction of GPIO. When set to output, we can control the output high or low level. When set to input, we can read the level of GPIO to determine the level of external input. ## 9.2 GPIO Programming Software Interface GPIO programming has multiple implementation methods. Here, we use sysfs to implement GPIO control.If you want to control gpio through sysfs, you first need the support of the underlying kernel. In order to implement kernel support for sysfs gpio, we need to set it in the kernel. When compiling the kernel, add Device Drivers-> GPIO Support ->/sys/class/gpio/… (sysfs interface). As a GPIO pin, it is not allowed to be used for other purposes in the kernel.After the system runs normally, we can see the sysfs control-related interfaces under /sys/class/gpio. There are three types of interfaces, namely control interface, GPIO signal and GPIO controller. For a detailed introduction to this part, please refer to "kernel\Documentation\gpio\sysfs.txt". #### 9.2.1 Control interfaceThe control interface is used to implement GPIO control in user space, mainly including /sys/class/gpio/export and /sys/class/gpio/unexport. These two control interfaces are write-only. /sys/class/gpio/export implements the export of GPIO control from kernel space to user space, and /sys/class/gpio/unexport is used to cancel the export of GPIO control from kernel space to user space. Below, we take the GPIO with pin number 19 as an example. In the /sys/class/gpio/ directory, after we execute "echo 19 > export", a "gpio19" node will be generated to control the GPIO with pin number 19. After we execute "echo 19 > unexport", the "gpio19" node previously generated by export will be deleted. In order to use gpio, we need to first use /sys/class/gpio/export to export the gpio pin number. After use, delete the previously exported gpio pin through /sys/class/gpio/unexport. #### 9.2.2 GPIO signal The GPIO signal is the GPIO itself, and its path is /sys/class/gpio/gpioN/, which has multiple attributes. By controlling these attributes, you can control the GPIO. * The "direction" attribute, the read value is "in" or "out". By writing "in" or "out" to this property, you can set the GPIO to input or output. If you write "out" directly, the GPIO will directly output a low level. You can also write "low" or "high" to directly set the output low or high level. * The "value" property is used to read the input level or control the output level. If the GPIO is an output, writing 0 to value is a low output level, and writing non-0 is a high output level. If it is set to input, reading 0 means the input is a low level, and 1 is a high level. * The "edge" property is used to set the trigger level. This property only appears when the GPIO can be set as an interrupt input pin. #### 9.2.3 GPIO controller GPIO controller is used to represent the initial GPIO implemented by GPIO control. Its path is /sys/class/gpio/gpiochipN/. For example, /sys/class/gpio/gpiochip42/ means that the initialization number of the GPIO controller is 42. The properties of the GPIO controller are read-only properties, including base, label, and ngpio. * The "base" property has the same meaning as the N in gpiochipN, indicating the first GPIO implemented by the GPIO controller. * The "ngpio" property is used to indicate how many GPIOs the controller supports. The supported GPIO numbers are from N to N+ngpio-1. * The "label" property is used to determine the controller and is not always unique.## 9.3 Determination of GPIO numbering of IMX6ULL development board Each chip can have N groups of GPIOs, and each group of GPIOs has a maximum of 32 GPIOs, that is, a maximum of N*32 GPIOs. However, in actual designs, the number of GPIOs in each group is different. In IMX6ULL, the actual number of GPIOs in each group is shown in the figure below. For details, see page 1347 of the "IMX6ULLRM.pdf" manual. As can be seen from the above picture, there are 5 groups of GPIO in IMX6ULL, and the starting GPIO group is GPIO1. Therefore, in the actual GPIO number calculation, the first group GPIO1 corresponds to numbers 0~31. Similarly, the corresponding number of GPION_X (N=1~5, X=0~31) of IMX6ULL is actually (N-1)*32+X. Next, we take the GPIOs corresponding to the onboard LED and button as examples to illustrate how to calculate the GPIO number in actual applications. ### 9.3.1 Calculation of GPIO number of LED Find the design of the corresponding LED from the schematic diagram, and the specific connection is shown in the figure below. From the figure, we can see that the GPIO connected to the LED is GPIO5_3, and its corresponding GPIO number is actually (5-1)*32+3 = 131. Therefore, if we want to operate the LED in sys_gpio, we need to export the GPIO numbered 131.  ### 9.3.2 Calculation of GPIO number of button Find the design of the corresponding buttons from the schematic diagram. There are 2 buttons on the baseboard. The specific connections are shown in the figure below. From the figure, we can see that the GPIOs connected to the two buttons are GPIO5_1 and GPIO4_14 respectively. The GPIO number corresponding to the first button KEY1 is (5-1) *32+1 = 129, and the GPIO number corresponding to the second button KEY2 is (4-1) *32+14=110. Therefore, if we want to read the values of buttons KEY1 and KEY2 in sys_gpio, we need to export the GPIOs numbered 129 and 110.  ### 9.3.3 GPIO number calculation in special cases In some cases, the starting gpiochipN is not gpiochip0. In this case, we need to add the starting gpiochipN value to the original GPIO number for calculation. The following figure shows the case where the actual gpiochip is gpiochip0.  ## 9.4 Actual Programming Operation In actual operation, we use LED and button to implement GPIO output and input experiments. The relevant experimental process and related codes are as follows. ### 9.4.1 Export GPIO port In order to export the GPIO port, we need to write the pin number to be exported to /sys/class/gpio/export. After use, we can also use /sys/class/gpio/unexport to unexport the pin number. The implementation code for exporting the pin number is as follows. For details, see the sysfs_gpio_export() function in "sysfs_gpio_1_export_gpio sysfs_gpio_export.c". ```c 32 int sysfs_gpio_export(unsigned int gpio) 33 { 34 int fd, len; 35 char buf[MAX_BUF]; 36 // /sys/class/gpio/export 37 fd = open( "/sys/class/gpio/export", O_WRONLY);//Open file 38 if (fd < 0) { 39 perror("gpio/export"); 40 return fd; 41 } 42 43 len = snprintf(buf, sizeof(buf), "%d", gpio);//Convert from a number to a string, that is, 1 becomes "1" 44 write(fd, buf, len);//Write the GPIO pin number to be exported 45 close(fd);//Close the file 46 47 return 0; 48 } ``` The implementation code for unexporting the pin number is as follows. For details, see the sysfs_gpio_unexport() function in "sysfs_gpio_export.c". ```c 59 int sysfs_gpio_unexport(unsigned int gpio) 60 { 61 int fd, len; 62 char buf[MAX_BUF]; 63 // /sys/class/gpio/unexport 64 fd = open("/sys/class/gpio/unexport", O_WRONLY);//Open file 65 if (fd < 0) { 66 perror("gpio/export"); 67 return fd; 68 } 69 70 len = snprintf(buf, sizeof(buf), "%d", gpio);//Convert from a number to a string, that is, 1 becomes "1" 71 write(fd, buf, len);//Write the GPIO pin number to be unexported 72 close(fd);//Close the file 73 return 0; 74 } ``` After implementing the functions of exporting and unexporting pin numbers, let's implement the export of specific pin numbers. The pin numbers corresponding to the LED and button are as follows```c 11 #define GPIO4_14 110 12 #define GPIO5_1 129 13 #define GPIO5_3 131 14 15 #define GPIO_KEY1 GPIO4_14 16 #define GPIO_KEY2 GPIO5_1 17 #define GPIO_LED GPIO5_3 ```After determining the corresponding pin numbers, we can export them. The specific implementation code is in the main function of the program file "sysfs_gpio_1_export_gpio/sysfs_gpio_export.c". The following is the corresponding code part. We have exported the pins corresponding to the LED and button. ```c 183 int main(int argc, char **argv) { 184 unsigned int i; 185 unsigned int value1,value2; 186 187 printf("\t********************************************\n"); 188 printf("\t******** SYSFS_GPIO_TEST_DEMO******************\n"); 189 printf("\t ******** version date: 2020/05 **********\n"); 190 printf("\t************************************************\n"); 191 192 printf("gpio begin to export gpio\r\n"); 193 sysfs_gpio_export(GPIO_KEY1);//export gpio key1 194 sysfs_gpio_export(GPIO_KEY2);//export gpio key2 195 sysfs_gpio_export(GPIO_LED);//export gpio led 196 printf("gpio export gpio ok\r\n"); 197 198 199 return 0; 200 } ```After compiling the code, we run the code on the board. The result after running the code is shown in the figure below. You can see that GPIO110, GPIO129 and GPIO131 are successfully exported.  ### 9.4.2 Setting GPIO Direction In order to set the direction of the exported pins, we need to write different values to /sys/class/gpio/gpioN/direction. Writing "in" means setting it as input, and writing "out" means setting it as output. The implementation code for setting the pin number is as follows. For details, see the sysfs_gpio_set_dir () function in "sysfs_gpio_2_export_gpio sysfs_gpio_export.c". ```c 86 int sysfs_gpio_set_dir(unsigned int gpio, unsigned int out_flag) 87 { 88 int fd,103 104 close(fd);//Close the file 105 return 0; 106 } ``` After implementing the pin direction setting function, we set different directions for the button and LED respectively. Set the button to input "IN" and the LED to output "out". The corresponding code is shown in the figure below. The relevant code is in the main function of the program file "sysfs_gpio_2_export_gpio/sysfs_gpio_export.c". The following is the corresponding code part. ```c 183 int main(int argc, char **argv) { 184 unsigned int i; 185 unsigned int value1,value2; 186 187 printf("\t********************************************\n"); 188 printf("\t******** SYSFS_GPIO_TEST_DEMO******************\n"); 189 printf("\t ******** version date: 2020/05 **********\n"); 190 printf("\t************************************************\n"); 191 192 printf("begin to export gpio and direction\r\n"); 193 sysfs_gpio_export(GPIO_KEY1);//export gpio key1 194 197 sysfs_gpio_set_dir(GPIO_KEY1, 0);//set as input 198 sysfs_gpio_set_dir(GPIO_KEY2, 0);//set as input 199 sysfs_gpio_set_dir(GPIO_LED, 1);//set as output 200 printf(" export gpio and direction ok\r\n"); 201 202 203 204 return 0; 205 } ```After compiling the code, we will run the code on the board. The result after running the code is shown in the figure below. We can see that the direction of the buttons GPIO110 and GPIO129 are set to input, and the GPIO131 of LED2 is set to input.  ### 9.4.3 GPIO output experiment-LED output control In order to set the output level of the pin, we need to write different values to /sys/class/gpio/gpioN/value. Writing '1' means output high level, and writing '0' means output low level. The implementation code for setting the pin output high and low level is as follows. For details, see the sysfs_gpio_set_value () function in "sysfs_gpio_3_export_gpio sysfs_gpio_export.c". ```c 119 int sysfs_gpio_set_value(unsigned int gpio, unsigned int value) 120 { 121 int fd, len; 122 char buf[MAX_BUF]; 123 // /sys/class/gpio/gpioN/value 124 len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/gpio%d/value", gpio); 125 126 fd = open(buf, O_WRONLY);//Open file 127 if (fd < 0) { 128 perror(buf); 129 return fd; 130 } 131 132 if (value)//is 1, write "1", that is, set to output high level 133 write(fd, "1", 2); 134 else //If it is 0, write "0", that is, set it to output low level 135 write(fd, "0", 2); 136 137 close(fd);//Close the file 138 return 0; 139 } ```After implementing the control function of the pin output level, let's implement the control of the LED. We control the GPIO output high or low level by writing "1" or "0" to value. The specific relevant code is in the main function in the program file "sysfs_gpio_3_export_gpio/sysfs_gpio_export.c". The following is the corresponding code part. ```c 183 int main(int argc, char **argv) { 184 unsigned int i; 185 unsigned int value1,value2; 186 187 printf("\t********************************************** ***\n"); 188 printf("\t******** SYSFS_GPIO_TEST_DEMO******************\n"); 189 printf("\t** ****** version date: 2020/05 **********\n"); 190 printf("\t********************** ***************************\n"); 191 192 printf("led begin to init\r\n"); 193 sysfs_gpio_export (GPIO_LED);//export gpio led 194 195 sysfs_gpio_set_dir(GPIO_LED, 1);//set as output 196 printf("led init ok\r\n"); 197 198 199 /* Confirm INIT_B Pin as High */ 200 while(1) 201 { 202 203 204 sysfs_gpio_set_value(GPIO_LED, 1);//output high 205 printf("led off\r\n"); 206 usleep(500000); //delay 207 sysfs_gpio_set_value(GPIO_LED, 0);//output low 208 printf("led on\r\n"); 209 usleep(500000);//delay 210 } 211 212 sysfs_gpio_unexport(GPIO_LED);//unexport gpio led 213 214 return 0; 215 } ```After compiling the code, we run it on the board. The result after running the code is shown in the figure below. You can see the regular printing of LED control information (the LED light flashes in the real object).  ### 9.4.4 GPIO input test - key value reading In order to read the level of the pin input, we need to read the value of /sys/class/gpio/gpioN/value. If the input is '1', it means the input is high level, and if the input is '0', it means the input is low level. The implementation code for reading the pin input level is as follows. For details, see " sysfs_gpio_4_export_gpio sysfs_gpio_export.c》sysfs_gpio_get_value() function. ```c 152 int sysfs_gpio_get_value(unsigned int gpio, unsigned int *value) 153 { 154 int fd, len; 155 char buf[MAX_BUF]; 156 char ch; 157 // /sys/class/gpio/gpioN/value 158 len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/gpio%d/value", gpio); 159 160 fd = open(buf, O_RDONLY);//Open the file 161 if (fd < 0) { 162 perror( "gpio/get-value"); 163 return fd; 164 } 165 166 read(fd, &ch, 1);//Read external input level 167 168 if (ch != '0') {//If it is '1', set it to 1, that is, the input is high level 169 *value = 1; 170 } else {//If it is '0', set it to 0, that is Input is low level 171 *value = 0; 172 } 173 174 close(fd);//Close file 175 return 0; 176 } ```After implementing the pin level reading function, let's implement the external button It is worth reading. We read the key value by reading the value of value. The specific related code is in the main function of the program file "sysfs_gpio_4_export_gpio/sysfs_gpio_export.c". The following is the corresponding code part. ```c 183 int main(int argc, char **argv) { 184 unsigned int i; 185 unsigned int value1,value2; 186 187 printf("\t************** ******************************\n"); 188 printf("\t************ SYSFS_GPIO_TEST_DEMO ****************\n"); 189 printf("\t************ version date: 2020/05 **********\ n"); 190 printf("\t****************************************** ****\n"); 191 192 printf("key begin to init\r\n"); 193 sysfs_gpio_export(GPIO_KEY1);//export gpio key1 194 sysfs_gpio_export(GPIO_KEY2);//export gpio key2 195 196 sysfs_gpio_set_dir(GPIO_KEY1, 0);//set as input 197 sysfs_gpio_set_dir(GPIO_KEY2,0);//set as input 198 199 printf("key init ok\r\n"); 200 201 202 /* Confirm INIT_B Pin as High */ 203 while(1) 204 { 205 206 sysfs_gpio_get_value(GPIO_KEY1, &value1) ; //read key1 value 207 //printf("@@key1 value 1is %d \n\r",value1); 208 if(value1==0)//key1 pressed 209 { 210 printf("@@key1 is pressed 0\n\r"); 211 } 212 sysfs_gpio_get_value(GPIO_KEY2, &value2);//read key2 value 213 //printf("##key2 value 1is %d \n\r",value2); 214 if(value2==0)//key2 pressed 215 { 216 printf("##key2 is pressed 0\n\r"); 217 } 218 usleep(100000);//delay 219 220 } 221 222 sysfs_gpio_unexport(GPIO_KEY1 );//unexport gpio key1 223 sysfs_gpio_unexport(GPIO_KEY2);//unexport gpio key2 224 225 226 return 0; 227 } ```After compiling the code, we run the code on the board. The result is shown in the figure below. We can see that the values printed after pressing keys KEY1 and KEY2 are different.  ### 9.4.5 LED and button control experiments In the previous experiments, we implemented LED and In this experiment, we integrate the previous experiments to control the flashing of the LED and read the value of the button. When the button is pressed, print the relevant information. The specific relevant code is in the main function in the program file "sysfs_gpio_5_export_gpio/sysfs_gpio_export.c". The following is the corresponding code part```c 183 int main(int argc, char **argv) { 184 unsigned int i; 185 unsigned int value1, value2; 186 187 printf("\t********************************************* ***\n"); 188 printf("\t******** SYSFS_GPIO_TEST_DEMO**************\n"); 189 printf("\t** ****** version date: 2020/05 **********\n"); 190 printf("\t***************** ***************************\n"); 191 192 printf("led&key begin to init\r\n"); 193 sysfs_gpio_export(GPIO_KEY1);//export gpio key1 194 sysfs_gpio_export(GPIO_KEY2);//export gpio key2 195 sysfs_gpio_export(GPIO_LED);//export gpio led 196 sysfs_gpio_set_dir(GPIO_KEY1, 0 );//set as input 197 sysfs_gpio_set_dir(GPIO_KEY2, 0);//set as input 198 sysfs_gpio_set_dir(GPIO_LED, 1);//set as output 199 printf("led&key init ok\r\n"); 200 201 202 /* Confirm INIT_B Pin as High */ 203 while( 1) 204 { 205 206 sysfs_gpio_get_value(GPIO_KEY1, &value1); //read key1 value 207 //printf("@@key1 value 1is %d \n\r",value1); 208 if(value1==0)//key1 pressed 209 { 210 printf ("@@key1 is pressed 0\n\r"); 211 } 212 sysfs_gpio_get_value(GPIO_KEY2, &value2);//read key2 value 213 //printf("##key2 value 1is %d \n\r",value2 ); 214 if(value2==0)//key2 pressed 215 { 216 printf("##key2 is pressed 0\n\r"); 217 } 218 //led flash 219 sysfs_gpio_set_value(GPIO_LED, 1); 220 printf("LED OFF\n\r"); 221 usleep(500000); 222 sysfs_gpio_set_value(GPIO_LED,0); 223 printf("LED ON\n\r"); 224 usleep(500000); 225 } 226 227 sysfs_gpio_unexport(GPIO_KEY1);//unexport gpio key1 228 sysfs_gpio_unexport(GPIO_KEY2);//unexport gpio key2 229 sysfs_gpio_unexport(GPIO_LED);//unexport gpio led 230 231 return 0; 232 } ```After compiling the code, we run the code on the board. The result after running the code is shown in the figure below. You can see that the LED flashes, and the values printed after pressing the keys KEY1 and KEY2 are different (because the flashing of the LED causes the key to be read after the LED flashes once, so the key must be pressed continuously to read the value change).