树莓派外设直接编程驱动

apple_eat

  目前树莓派python版本的硬件驱动库只能使用GPIO,SPI等,很多外设的功能都没办法用.
可以使用mmap映射物理地址,直接操作外设的寄存器,这样树莓派的整个硬件资源就可以打通了.下面是通过操作GPIO寄存器控制一个引脚的例子,其他的外设也可以参照操作.

1. #include <stdint.h>
   
2. #include <stdbool.h>
   
3. #include <stdlib.h>
   
4. #include <stdio.h>
   
5. 
   
6. #include <fcntl.h>                // 文件打开、加锁等操作
   
7. #include <unistd.h>                // unistd.h 是 C 和 C++ 程序设计语言中提供对 POSIX 操作系统 API 的访问功能的头文件的名称。是Unix Standard的缩写。
   
8. #include <errno.h>                // errno.h是C语言C标准库里的头文件，定义了通过错误码来回报错误信息的宏：
   
9. 
   
10. #include <sys/ioctl.h>
    
11. #include <sys/types.h>
    
12. #include <sys/stat.h>
    
13. #include <sys/mman.h>        // 内存管理，包括POSIX 共享内存 (进程间通信)与内存映射文件
    
14. 
    
15. #define PERIPH_BASE_RPI2        0x3F000000
    
16. #define GPIO_OFFSET                        0x00200000
    
17. 
    
18. typedef struct
    
19. {
    
20.         uint32_t fsel[6];                            // GPIO Function Select
    
21.         uint32_t resvd_0x18;
    
22.         uint32_t set[2];                             // GPIO Pin Output Set
    
23.         uint32_t resvd_0x24;
    
24.         uint32_t clr[2];                             // GPIO Pin Output Clear
    
25.         uint32_t resvd_0x30;
    
26.         uint32_t lev[2];                             // GPIO Pin Level
    
27.         uint32_t resvd_0x3c;
    
28.         uint32_t eds[2];                             // GPIO Pin Event Detect Status
    
29.         uint32_t resvd_0x48;
    
30.         uint32_t ren[2];                             // GPIO Pin Rising Edge Detect Enable
    
31.         uint32_t resvd_0x54;
    
32.         uint32_t fen[2];                             // GPIO Pin Falling Edge Detect Enable
    
33.         uint32_t resvd_0x60;
    
34.         uint32_t hen[2];                             // GPIO Pin High Detect Enable
    
35.         uint32_t resvd_0x6c;
    
36.         uint32_t len[2];                             // GPIO Pin Low Detect Enable
    
37.         uint32_t resvd_0x78;
    
38.         uint32_t aren[2];                            // GPIO Pin Async Rising Edge Detect
    
39.         uint32_t resvd_0x84;
    
40.         uint32_t afen[2];                            // GPIO Pin Async Falling Edge Detect
    
41.         uint32_t resvd_0x90;
    
42.         uint32_t pud;                                // GPIO Pin Pull up/down Enable
    
43.         uint32_t pudclk[2];                          // GPIO Pin Pull up/down Enable Clock
    
44.         uint32_t resvd_0xa0[4];
    
45.         uint32_t test;
    
46. } __attribute__((packed, aligned(4))) gpio_t;
    
47. 
    
48. volatile gpio_t * gpio;
    
49. 
    
50. void GPIO_WriteHigh(gpio_t * gpio, int pin)
    
51. {
    
52.         if (pin > 53)
    
53.                 return;
    
54.         int reg = pin >> 5;
    
55.         int offset = (pin & 0x1F);
    
56.         gpio->set[reg] |= (1 << offset);
    
57. }
    
58. 
    
59. void GPIO_WriteLow(gpio_t * gpio, int pin)
    
60. {
    
61.         if (pin > 53)
    
62.                 return;
    
63.         int reg = pin / 32;
    
64.         int offset = pin % 32;
    
65.         gpio->clr[reg] |= (1 << offset);
    
66. }
    
67. 
    
68. typedef enum
    
69. {
    
70.         GPIO_Function_Input = 0,
    
71.         GPIO_Function_Output = 1,
    
72.         GPIO_Function_Alternate0 = 2,
    
73.         GPIO_Function_Alternate1 = 3,
    
74.         GPIO_Function_Alternate2 = 4,
    
75.         GPIO_Function_Alternate3 = 5,
    
76.         GPIO_Function_Alternate4 = 6,
    
77.         GPIO_Function_Alternate5 = 7
    
78. }GPIO_FUNCTION_SEL;
    
79. 
    
80. void GPIO_SetMode(gpio_t * gpio, int pin, GPIO_FUNCTION_SEL sel)
    
81. {
    
82.         if (pin > 53)
    
83.                 return;
    
84.         int reg = pin / 10;
    
85.         int offset = (pin % 10) * 3;
    
86.         gpio->fsel[reg] &= ~(0x00000007 << offset);
    
87.         gpio->fsel[reg] |= (sel << offset);
    
88. }
    
89. 
    
90. 
    
91. int main(int argc, char * argv[])
    
92. {
    
93.         int mem_fd;
    
94. 
    
95.         mem_fd = open("/dev/mem", O_RDWR);
    
96.         if (mem_fd == -1)
    
97.         {
    
98.                 perror("mem");
    
99.                 exit(0);
    
100.         }
     
101. 
     
102.         gpio = mmap(0, sizeof(gpio_t), PROT_READ | PROT_WRITE, MAP_SHARED, mem_fd, (PERIPH_BASE_RPI2 + GPIO_OFFSET));
     
103.         if (gpio == MAP_FAILED)
     
104.         {
     
105.                 perror("mmap");
     
106.                 exit(0);
     
107.         }
     
108. 
     
109.         GPIO_SetMode(gpio, 18, GPIO_Function_Output);
     
110. 
     
111.         while (true)
     
112.         {
     
113.                 GPIO_WriteHigh(gpio, 18);
     
114.                 sleep(1);
     
115.                 GPIO_WriteLow(gpio, 18);
     
116.                 sleep(1);
     
117.         }
     
118. 
     
119.         return 0;
     
120. }

复制代码

four_zhg

不错，这样的话，其它端口就也可以使用了

apple_eat

four_zhg 发表于 2016-12-1 15:56
不错，这样的话，其它端口就也可以使用了

还可以通过DMA+PWM的方式直接驱动ws2812b,
Github上有一个项目https://github.com/jgarff/rpi_ws281x

XIVN1987

Python也可以

wxws_wxws

哈，终于有人聊树莓派了

TIANYJ

这个消息真是太好了，可以直接调试外设。

NJ8888

几年前就用mmap操作linux下硬件，不知道树莓的寄存器手册是否详细？一直没玩

hexenzhou

不错，支持一下。我的PI3快长灰了。

chinazhaoyl

好，空闲时候玩玩

fengyunyu

mmap方式，很多人都这样搞！

apple_eat

XIVN1987 发表于 2016-12-1 16:52
Python也可以

这个还真没了解过,python功能挺强大的呀.

genhao2

python类库很多