三种方式控制NanoPi2的GPIO

今天药忘吃喽~ 2022-09-21 13:20 250阅读 0赞

首先奉上PDF资料，万变不离其宗，掌握核心科技才是最重要的：  
  
![pdf.gif][] [SEC\_Users\_Manual\_S5P4418\_Users\_Manual\_Preliminary\_Ver.0.10.pdf][SEC_Users_Manual_S5P4418_Users_Manual_Preliminary_Ver.0.10.pdf] (12.59 MB, 下载次数: 37)   
  
我目前找到了三种方式控制NanoPi2的IO口：

*  通过sysfs(/sys/class/gpio)来操作；
 *  通过内核的gpio\_set\_value函数来操作；
 *  通过配置寄存器(0xC001X000)来操作。

1. 通过sysfs来操作

这种方法是官方教程给出的办法，这里只给出链接，不再详细解释。

[http://bbs.elecfans.com/jishu\_527063\_1\_1.html][http_bbs.elecfans.com_jishu_527063_1_1.html]

2. 通过内核函数来操作  
首先，用户层需要和驱动层交流，目前我知道的是两种方式，一种是通过ioctl操作，另一种是基于文件操作。注意，不管是基于ioctl还是文件操作，速度都是在200us这个数量级上，也就是0.2ms。  
2.1 基于ioctl操作  
下面是一段我自己写的内核代码，以及操作这个内核模块的demo。  
2.1.1 内核模块  
这个内核模块控制的是GPIOC11引脚，通过ioctl发送SET\_VALUE命令可以设置引脚输出电平的高低，也就是LED的亮灭。使用的函数是：

1.  gpio\_request(GPIOC11, "test");  
    
2.  gpio\_direction\_output(GPIOC11, 1);  
    
3.  gpio\_set\_value(GPIOC11, HIGH);

复制代码

下面是全部代码：

1.  \#include <linux/kernel.h>  
    
2.  \#include <linux/module.h>  
    
3.  \#include <linux/gpio.h>  
    
4.  \#include <linux/miscdevice.h>  
    
5.  \#include <linux/fs.h>  
    
6.  \#include <linux/moduleparam.h>  
    
7.  \#include <linux/slab.h>  
    
8.  \#include <linux/cdev.h>  
    
9.  \#include <linux/delay.h>  
    
10. \#include <linux/compat.h>  
    
11.   
    
12. \#include <linux/spi/spi.h>  
    
13. \#include <linux/spi/spidev.h>  
    
14.   
    
15. \#include <mach/platform.h>  
    
16. \#include <mach/devices.h>  
    
17.   
    
18. \#define OUTPUT  1  
    
19. \#define INPUT   0  
    
20. \#define HIGH    1  
    
21. \#define LOW     0  
    
22.   
    
23. \#define SET\_VALUE 123  
    
24. unsigned int GPIOC11 = PAD\_GPIO\_C + 11;  
    
25. \#define DEVICE\_NAME "gpio"  
    
26.   
    
27. static int gpio\_open(struct inode \*inode, struct file \*file)  
    
28. \{  
    
29.     gpio\_request(GPIOC11, "test");  
    
30.     gpio\_direction\_output(GPIOC11, 1);  
    
31.     printk("request GPIOC11\\n");  
    
32.     return 0;  
    
33. \}  
    
34.   
    
35. static int gpio\_close(struct inode \*inode, struct file \*file)\{  
    
36.     printk("gpio\_set\_value LOW\\n");  
    
37.     gpio\_set\_value(GPIOC11, LOW);  
    
38.     gpio\_free(GPIOC11);  
    
39.     return 0;  
    
40. \}  
    
41.   
    
42. static long   
    
43. gpio\_ioctl(struct file \*file, unsigned int cmd, unsigned long arg) \{  
    
44.     if(cmd == SET\_VALUE)\{  
    
45.         if(arg == HIGH)\{  
    
46.             gpio\_set\_value(GPIOC11, HIGH);  
    
47.             printk("gpio\_set\_value HIGH\\n");  
    
48.         \}else if(arg == LOW)\{  
    
49.             gpio\_set\_value(GPIOC11, LOW);  
    
50.             printk("gpio\_set\_value LOW\\n");  
    
51.         \}  
    
52.     \}  
    
53.     return -EMSGSIZE;  
    
54. \}  
    
55.   
    
56. static struct file\_operations gpio\_fops = \{  
    
57.     .owner = THIS\_MODULE,  
    
58.     .open = gpio\_open,  
    
59.     .release = gpio\_close,  
    
60.     .unlocked\_ioctl = gpio\_ioctl,  
    
61. \};  
    
62.   
    
63. static struct miscdevice gpio\_dev = \{  
    
64.     .minor          = MISC\_DYNAMIC\_MINOR,  
    
65.     .name          = DEVICE\_NAME,  
    
66.     .fops          = &gpio\_fops,  
    
67. \};  
    
68.   
    
69. volatile unsigned \* GPIOCOUT;  
    
70.   
    
71. static int gpio\_init(void)\{  
    
72.     int ret = 0;  
    
73.     printk("init\\n");  
    
74.     ret = misc\_register(&gpio\_dev);  
    
75.     return ret;  
    
76. \}  
    
77.   
    
78. static void gpio\_exit(void)\{  
    
79.     misc\_deregister(&gpio\_dev);  
    
80.     printk("exit\\n");  
    
81. \}  
    
82.   
    
83. module\_init(gpio\_init);  
    
84. module\_exit(gpio\_exit);  
    
85.   
    
86. MODULE\_LICENSE("GPL");  
    
87. MODULE\_AUTHOR("YPW");  
    
88.

复制代码

下面就是这个模块的Makefile：

1.  obj-m:=gpio.o  
    
2.  mymodule-objs:=gpio  
    
3.  KDIR:=/home/ypw/Desktop/linux-3.4.y/  
    
4.  MAKE:=make  
    
5.  \# EXTRA\_CFLAGS += -I$(KDIR)arch/arm/mach-s5p4418/prototype/module  
    
6.  default:  
    
7.          $(MAKE) -C $(KDIR) M=$(PWD) modules  
    
8.  clean:  
    
9.          $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) clean  
    
10.

复制代码

如果你需要编译这个内核模块，你首先需要下载linux内核的源代码：https://github.com/friendlyarm/linux-3.4.y，然后将KDIR修改为你的内核地址，make即可编译出gpio.ko。如果不想自己编译，只想使用GPIOC11，可以下载我编译好的内核模块：gpio\_ioctl.ko  
2.1.2 操作demo  
安装和删除内核模块的办法：

1.  insmod gpio\_ioctl.ko  
    
2.  rmmod gpio\_ioctl.ko

复制代码

安装好以后，如何使用呢？

1.  \#include <stdio.h>  
    
2.  \#include <fcntl.h>  
    
3.  \#include <sys/ioctl.h>  
    
4.  \#define HIGH    1  
    
5.  \#define LOW     0  
    
6.    
    
7.  \#define SET\_VALUE 123  
    
8.    
    
9.  int main()  
    
10. \{  
    
11.         int fd = open("/dev/gpio", O\_RDWR);  
    
12.         int i;  
    
13.         for(i=0;i<3;i++)\{  
    
14.                 ioctl(fd, SET\_VALUE, HIGH);  
    
15.                 usleep(100000);  
    
16.                 ioctl(fd, SET\_VALUE, LOW);  
    
17.                 usleep(100000);  
    
18.         \}  
    
19.         close(fd);  
    
20.         return 0;  
    
21. \}  
    
22.

复制代码

1.  gcc gpio\_ioctl.c -o gpio\_ioctl  
    
2.  ./gpio\_ioctl

复制代码

编译运行，即可看到灯闪三下。  
http://yangpeiwen.com/wp-content/uploads/2016/01/gpio.mp4  
  
2.2 基于文件操作  
2.2.1 内核代码：

1.  \#include <linux/kernel.h>  
    
2.  \#include <linux/module.h>  
    
3.  \#include <linux/gpio.h>  
    
4.  \#include <linux/miscdevice.h>  
    
5.  \#include <linux/fs.h>  
    
6.  \#include <linux/moduleparam.h>  
    
7.  \#include <linux/slab.h>  
    
8.  \#include <linux/cdev.h>  
    
9.  \#include <linux/delay.h>  
    
10. \#include <linux/compat.h>  
    
11.   
    
12. \#include <linux/spi/spi.h>  
    
13. \#include <linux/spi/spidev.h>  
    
14.   
    
15. \#include <mach/platform.h>  
    
16. \#include <mach/devices.h>  
    
17.   
    
18. \#define OUTPUT  1  
    
19. \#define INPUT   0  
    
20. \#define HIGH    1  
    
21. \#define LOW     0  
    
22.   
    
23. \#define SET\_VALUE 123  
    
24. unsigned int GPIOC11 = PAD\_GPIO\_C + 11;  
    
25. \#define DEVICE\_NAME "gpio"  
    
26.   
    
27. static int gpio\_open(struct inode \*inode, struct file \*file)  
    
28. \{  
    
29.     gpio\_request(GPIOC11, "test");  
    
30.     gpio\_direction\_output(GPIOC11, 1);  
    
31.     printk("request GPIOC11\\n");  
    
32.     return 0;  
    
33. \}  
    
34.   
    
35. static int gpio\_close(struct inode \*inode, struct file \*file)\{  
    
36.     printk("gpio\_set\_value LOW\\n");  
    
37.     gpio\_set\_value(GPIOC11, LOW);  
    
38.     gpio\_free(GPIOC11);  
    
39.     return 0;  
    
40. \}  
    
41.   
    
42. static ssize\_t   
    
43. gpio\_write(struct file \*filp, const char \_\_user \*buf,  
    
44.     size\_t count, loff\_t \*f\_pos) \{  
    
45.     if (count > 1)  
    
46.         return -EMSGSIZE;  
    
47.     if(buf\[0\] == '1')\{  
    
48.         gpio\_set\_value(GPIOC11, HIGH);  
    
49.         printk("gpio\_set\_value HIGH\\n");  
    
50.     \}else if(buf\[0\] == '0')\{  
    
51.         gpio\_set\_value(GPIOC11, LOW);  
    
52.         printk("gpio\_set\_value LOW\\n");  
    
53.     \}else\{  
    
54.         return -EMSGSIZE;  
    
55.     \}  
    
56.     return -EMSGSIZE;  
    
57. \}  
    
58.   
    
59. static struct file\_operations gpio\_fops = \{  
    
60.     .owner = THIS\_MODULE,  
    
61.     .open = gpio\_open,  
    
62.     .release = gpio\_close,  
    
63.     .write = gpio\_write,  
    
64. \};  
    
65.   
    
66. static struct miscdevice gpio\_dev = \{  
    
67.     .minor          = MISC\_DYNAMIC\_MINOR,  
    
68.     .name          = DEVICE\_NAME,  
    
69.     .fops          = &gpio\_fops,  
    
70. \};  
    
71.   
    
72. volatile unsigned \* GPIOCOUT;  
    
73.   
    
74. static int gpio\_init(void)\{  
    
75.     int ret = 0;  
    
76.     printk("init\\n");  
    
77.     ret = misc\_register(&gpio\_dev);  
    
78.     return ret;  
    
79. \}  
    
80.   
    
81. static void gpio\_exit(void)\{  
    
82.     iounmap(GPIOCOUT);  
    
83.     misc\_deregister(&gpio\_dev);  
    
84.     printk("exit\\n");  
    
85. \}  
    
86.   
    
87. module\_init(gpio\_init);  
    
88. module\_exit(gpio\_exit);  
    
89.   
    
90. MODULE\_LICENSE("GPL");  
    
91. MODULE\_AUTHOR("YPW");  
    
92.

复制代码

2.2.2 DEMO代码

1.  \#include <stdio.h>  
    
2.  int main()  
    
3.  \{  
    
4.          FILE \*p = fopen("/dev/gpio", "w");  
    
5.          int i;  
    
6.          for(i=0;i<3;i++)\{  
    
7.                  fprintf(p, "1");fflush(p);  
    
8.                  usleep(100000);  
    
9.                  fprintf(p, "0");fflush(p);  
    
10.                 usleep(100000);  
    
11.         \}  
    
12.         fclose(p);  
    
13.         return 0;  
    
14. \}

复制代码

这个比较简单，跟上面的一样，我就不过多讲了。如果不想自己编译，可以下载我编译好的内核模块：gpio\_file.ko  
  
不过有一点我想说的就是，可以通过寄存器加速控制IO口的速度，这里仅贴一个代码片段，只能在内核中操作，这种操作方式最快可以达到20ns：

1.  \#include <asm/io.h>  
    
2.  volatile unsigned \* GPIOCOUT;  
    
3.  GPIOCOUT = ioremap(0xC001C000, 4);  
    
4.  \*GPIOCOUT = 0xFFFF;  
    
5.  \*GPIOCOUT = 0;  
    
6.  iounmap(GPIOCOUT);

复制代码

3. 通过配置寄存器来操作  
下面这个程序在用户层即可操作寄存器，原理是通过mmap将寄存器的地址通过映射到用户层，然后控制方法参考三星PDF即可。

1.  \#include <stdio.h>  
    
2.  \#include <stdlib.h>  
    
3.  \#include <time.h>  
    
4.  \#include <unistd.h>  
    
5.  \#include <fcntl.h>  
    
6.  \#include <unistd.h>  
    
7.  \#include <sys/mman.h>  
    
8.    
    
9.  \#define GPIOC\_BASE\_ADDRESS   (0xC001C000)  
    
10. \#define MAP\_SIZE 40  
    
11. static int dev\_fd;  
    
12.   
    
13. int main(int argc, char \*\*argv)  
    
14. \{  
    
15.     dev\_fd = open("/dev/mem", O\_RDWR | O\_NDELAY);  
    
16.     if (dev\_fd < 0)  
    
17.     \{  
    
18.         printf("open(/dev/mem) failed.");  
    
19.         return 0;  
    
20.     \}  
    
21.     unsigned int base = (unsigned int)mmap(NULL, MAP\_SIZE, PROT\_READ | PROT\_WRITE, MAP\_SHARED, dev\_fd, GPIOC\_BASE\_ADDRESS );  
    
22.     \#define GPIOCOUT \*(unsigned int \*)base  
    
23.     \#define GPIOCOUTENB \*(unsigned int \*)(base+0x04)  
    
24.     \#define GPIOCALTFN0 \*(unsigned int \*)(base+0x20)  
    
25.     GPIOCALTFN0 &= ~(3<<22);  
    
26.     GPIOCALTFN0 |= (1<<22);  
    
27.     GPIOCOUTENB |= (1<<11);  
    
28.     GPIOCOUT |= (1<<11);  
    
29.     sleep(1);  
    
30.     GPIOCOUT &= ~(1<<11);  
    
31.     if(dev\_fd)  
    
32.         close(dev\_fd);  
    
33.     munmap((unsigned int \*)base,MAP\_SIZE);  
    
34.     return 0;  
    
35. \}

复制代码

效果是灯亮一秒，然后熄灭。这种方法操作速度很快，可以在80ns级别控制，而且很方便，不需要内核级的代码。

[pdf.gif]: /images/20220721/f1d5e9eeecb74530ba1f135b9d11a473.png
[SEC_Users_Manual_S5P4418_Users_Manual_Preliminary_Ver.0.10.pdf]: http://bbs.elecfans.com/forum.php?mod=attachment&aid=MzE1MTEzfDNkMzc4MjM2fDE0NjY1MDU1ODJ8MHw1NDExODk%3D
[http_bbs.elecfans.com_jishu_527063_1_1.html]: http://bbs.elecfans.com/jishu_527063_1_1.html