【嵌入式】强行写GPIO实现I2C通讯，控制SSD1306显示屏显示图像

0xAA55

SSD1306显示屏的PDF文档：https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf

这玩意儿是一个128x64分辨率（其实它有三种规格，我买的是这种）、单色、自带显存的玩意儿。它的接口有很多种，我买的是封装成i2c接口的。
控制它显示的原理很简单：开屏，写显存。完事儿。写显存后它就会立即把效果显示出来。当然它自己是有个刷新率的，会以一定频率不断读取显存并使用屏幕显示。
除了显存，它还有各种控制寄存器。和之前的用i2c操作MPU6050的情况不同，用i2c操作SSD1306的方式分为两种：

1、写命令
2、写显存

其中写命令的方式，PDF文档描述得不是很清楚，而官方资料居然是C艹的，它写了个C艹的类用于维护SSD1306，令人恼火。
不过这个C艹的资料也还算好懂。经过一次次尝试我知道了它是如何写命令和写显存的了。

写命令的方式：
1、开始条件。这个和之前的例子一样，最初SDA和SCL都是高电平，然后先拉低SDA，再拉低SCL。
2、写入芯片地址，以及R/W位。控制SSD1306不存在读取的过程，所以R/W位设为0，也就是低电平——写入。
3、从SSD1306读取ACK状态。不过SSD1306的SDA输出的pin不一定和I2C总线相连，所以它也可能不回应ACK。
4、写入控制字节。第7 bit是Continuation bit，不管它，写0。第6 bit是“命令/数据”bit，值为1的时候是写显存，值为0是写命令。其余位都是0。所以这次写入的控制字节其实是0。
5、读取ACK。
6、写入命令。
7、读取ACK。
8、结束条件：先拉高SCL，再拉高SDA。

当一个命令带有参数的时候，你要先用一次这种写命令的过程写入你的命令字节，再用一次这种写命令的过程写入你的命令参数。

写显存的方式：
1、开始条件。
2、芯片地址。
3、读取ACK。
4、写入控制字节。因为是写显存操作，这次写入的控制字节是0x40。
5、读取ACK。
6、写入你要写进显存的值。你写入后，它自己会把写显存的指针往后移，移动到结尾后又会归位到起始处。
7、读取ACK。
8、回到第6步。嗯其实这是个循环，你可以在此完成批量的写显存的操作，想写几个字节就写几个字节。
9、结束条件。

写显存的过程受到多个控制寄存器的影响。按照我这次写的代码对其进行的初始化的情况来看，你写入的一个字节，会成为它的显示指针所在的当前位置向下8个像素的状态值。然后它的显示指针是往右移动1个字节的。显示指针移动到最右后，又会自动移回最左，然后往下移动8个像素。这种设计，是为了便于让你通过直接写显存的方式来让它一行行地输出8个像素高的点阵字体。
不过你也可以把SSD1306_MEMORYMODE设为1（先发送命令“SSD1306_MEMORYMODE”（值为0x20），再发送命令“1”），来让它改变显示指针的移动行为——之前是向右移动1个像素，现在是向下移动8个像素。然后就可以构成一个从顶到下为x轴，从左到右为y轴的单色位图了。

这次的测试发现_i2c_delay()里面的usleep非常影响I2C的传输效率，它延迟的时长可能远超5us。估计和Bananapi M2的性能与时间片长度的设定有关。切走CPU会导致写入一整个显存要耗费接近1秒的时间。我把usleep(5)注释掉后，我发现它依然能完成通讯，并且显示屏的更新效率变得很高了。

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<string.h>
   
4. #include<stdarg.h>
   
5. #include<inttypes.h>
   
6. #include<wiringPi.h>
   
7. #include<unistd.h>
   
8. 
   
9. #define param_pins int scl_pin, int sda_pin
   
10. #define i2c_pin scl_pin, sda_pin
    
11. 
    
12. static void _i2c_delay()
    
13. {
    
14.         // usleep(5);
    
15.         // 不用延迟它也能实现效果
    
16.         // 用了延迟反而变得贼慢
    
17. }
    
18. 
    
19. static void _i2c_start(param_pins)
    
20. {
    
21.         pinMode(scl_pin, OUTPUT);
    
22.         pinMode(sda_pin, OUTPUT);
    
23.        
    
24.         // start condition
    
25.         digitalWrite(scl_pin, HIGH);
    
26.         _i2c_delay();
    
27.         digitalWrite(sda_pin, HIGH);
    
28.         _i2c_delay();
    
29.         digitalWrite(sda_pin, LOW);
    
30.         _i2c_delay();
    
31.         digitalWrite(scl_pin, LOW);
    
32.         _i2c_delay();
    
33. }
    
34. 
    
35. static void _i2c_stop(param_pins)
    
36. {
    
37.         pinMode(scl_pin, OUTPUT);
    
38.         pinMode(sda_pin, OUTPUT);
    
39.        
    
40.         digitalWrite(scl_pin, LOW);
    
41.         digitalWrite(sda_pin, HIGH);
    
42.         _i2c_delay();
    
43.         digitalWrite(scl_pin, HIGH);
    
44.         _i2c_delay();
    
45. }
    
46. 
    
47. static void _i2c_send_bit(param_pins, const int value)
    
48. {
    
49.         digitalWrite(sda_pin, value ? HIGH : LOW);
    
50.         digitalWrite(scl_pin, HIGH);
    
51.         _i2c_delay();
    
52.         digitalWrite(scl_pin, LOW);
    
53.         _i2c_delay();
    
54. }
    
55. 
    
56. static int _i2c_read_bit(param_pins)
    
57. {
    
58.         int received;
    
59.         digitalWrite(scl_pin, HIGH);
    
60.         _i2c_delay();
    
61.         received = digitalRead(sda_pin) == HIGH ? 1 : 0;
    
62.         digitalWrite(scl_pin, LOW);
    
63.         _i2c_delay();
    
64.         return received;
    
65. }
    
66. 
    
67. static int _i2c_read_byte(param_pins)
    
68. {
    
69.         int received = 0;
    
70.        
    
71.         pinMode(scl_pin, OUTPUT);
    
72.         pinMode(sda_pin, INPUT);
    
73.        
    
74.         received |= _i2c_read_bit(i2c_pin) << 7;
    
75.         received |= _i2c_read_bit(i2c_pin) << 6;
    
76.         received |= _i2c_read_bit(i2c_pin) << 5;
    
77.         received |= _i2c_read_bit(i2c_pin) << 4;
    
78.         received |= _i2c_read_bit(i2c_pin) << 3;
    
79.         received |= _i2c_read_bit(i2c_pin) << 2;
    
80.         received |= _i2c_read_bit(i2c_pin) << 1;
    
81.         received |= _i2c_read_bit(i2c_pin);
    
82.        
    
83.         // send NACK
    
84.         pinMode(sda_pin, OUTPUT);
    
85.         _i2c_send_bit(i2c_pin, 1);
    
86.         return received;
    
87. }
    
88. 
    
89. static void _i2c_write_byte(param_pins, const int value)
    
90. {
    
91.         pinMode(scl_pin, OUTPUT);
    
92.         pinMode(sda_pin, OUTPUT);
    
93.         _i2c_send_bit(i2c_pin, value & 0x80 ? 1 : 0);
    
94.         _i2c_send_bit(i2c_pin, value & 0x40 ? 1 : 0);
    
95.         _i2c_send_bit(i2c_pin, value & 0x20 ? 1 : 0);
    
96.         _i2c_send_bit(i2c_pin, value & 0x10 ? 1 : 0);
    
97.         _i2c_send_bit(i2c_pin, value & 0x08 ? 1 : 0);
    
98.         _i2c_send_bit(i2c_pin, value & 0x04 ? 1 : 0);
    
99.         _i2c_send_bit(i2c_pin, value & 0x02 ? 1 : 0);
    
100.         _i2c_send_bit(i2c_pin, value & 0x01 ? 1 : 0);
     
101. }
     
102. 
     
103. #define BLACK 0
     
104. #define WHITE 1
     
105. #define INVERSE 2
     
106. 
     
107. #define SSD1306_I2C_ADDRESS   0x3C  // 011110+SA0+RW - 0x3C or 0x3D
     
108. // Address for 128x32 is 0x3C
     
109. // Address for 128x64 is 0x3D (default) or 0x3C (if SA0 is grounded)
     
110. 
     
111. /*=========================================================================
     
112.     SSD1306 Displays
     
113.     -----------------------------------------------------------------------
     
114.     The driver is used in multiple displays (128x64, 128x32, etc.).
     
115.     Select the appropriate display below to create an appropriately
     
116.     sized framebuffer, etc.
     
117. 
     
118.     SSD1306_128_64  128x64 pixel display
     
119. 
     
120.     SSD1306_128_32  128x32 pixel display
     
121. 
     
122.     SSD1306_96_16
     
123. 
     
124.     -----------------------------------------------------------------------*/
     
125.    #define SSD1306_128_64
     
126. //   #define SSD1306_128_32
     
127. //   #define SSD1306_96_16
     
128. /*=========================================================================*/
     
129. 
     
130. #if defined SSD1306_128_64 && defined SSD1306_128_32
     
131.   #error "Only one SSD1306 display can be specified at once in SSD1306.h"
     
132. #endif
     
133. #if !defined SSD1306_128_64 && !defined SSD1306_128_32 && !defined SSD1306_96_16
     
134.   #error "At least one SSD1306 display must be specified in SSD1306.h"
     
135. #endif
     
136. 
     
137. #if defined SSD1306_128_64
     
138.   #define SSD1306_LCDWIDTH                  128
     
139.   #define SSD1306_LCDHEIGHT                 64
     
140. #endif
     
141. #if defined SSD1306_128_32
     
142.   #define SSD1306_LCDWIDTH                  128
     
143.   #define SSD1306_LCDHEIGHT                 32
     
144. #endif
     
145. #if defined SSD1306_96_16
     
146.   #define SSD1306_LCDWIDTH                  96
     
147.   #define SSD1306_LCDHEIGHT                 16
     
148. #endif
     
149. 
     
150. #define SSD1306_SETCONTRAST 0x81
     
151. #define SSD1306_DISPLAYALLON_RESUME 0xA4
     
152. #define SSD1306_DISPLAYALLON 0xA5
     
153. #define SSD1306_NORMALDISPLAY 0xA6
     
154. #define SSD1306_INVERTDISPLAY 0xA7
     
155. #define SSD1306_DISPLAYOFF 0xAE
     
156. #define SSD1306_DISPLAYON 0xAF
     
157. 
     
158. #define SSD1306_SETDISPLAYOFFSET 0xD3
     
159. #define SSD1306_SETCOMPINS 0xDA
     
160. 
     
161. #define SSD1306_SETVCOMDETECT 0xDB
     
162. 
     
163. #define SSD1306_SETDISPLAYCLOCKDIV 0xD5
     
164. #define SSD1306_SETPRECHARGE 0xD9
     
165. 
     
166. #define SSD1306_SETMULTIPLEX 0xA8
     
167. 
     
168. #define SSD1306_SETLOWCOLUMN 0x00
     
169. #define SSD1306_SETHIGHCOLUMN 0x10
     
170. 
     
171. #define SSD1306_SETSTARTLINE 0x40
     
172. 
     
173. #define SSD1306_MEMORYMODE 0x20
     
174. #define SSD1306_COLUMNADDR 0x21
     
175. #define SSD1306_PAGEADDR   0x22
     
176. 
     
177. #define SSD1306_COMSCANINC 0xC0
     
178. #define SSD1306_COMSCANDEC 0xC8
     
179. 
     
180. #define SSD1306_SEGREMAP 0xA0
     
181. 
     
182. #define SSD1306_CHARGEPUMP 0x8D
     
183. 
     
184. #define SSD1306_EXTERNALVCC 0x1
     
185. #define SSD1306_SWITCHCAPVCC 0x2
     
186. 
     
187. // Scrolling #defines
     
188. #define SSD1306_ACTIVATE_SCROLL 0x2F
     
189. #define SSD1306_DEACTIVATE_SCROLL 0x2E
     
190. #define SSD1306_SET_VERTICAL_SCROLL_AREA 0xA3
     
191. #define SSD1306_RIGHT_HORIZONTAL_SCROLL 0x26
     
192. #define SSD1306_LEFT_HORIZONTAL_SCROLL 0x27
     
193. #define SSD1306_VERTICAL_AND_RIGHT_HORIZONTAL_SCROLL 0x29
     
194. #define SSD1306_VERTICAL_AND_LEFT_HORIZONTAL_SCROLL 0x2A
     
195. 
     
196. #define stop_if_nack 1
     
197. #define ignore_nack 0
     
198. 
     
199. typedef struct ssd1306_i2c_ctrl_struct
     
200. {
     
201.         int sda_pin;
     
202.         int scl_pin;
     
203.         int chip_addr;
     
204.         int check_ack;
     
205. }ssd1306_i2c_ctrl_t, *ssd1306_i2c_ctrl_p;
     
206. 
     
207. void ssd1306_i2c_init(ssd1306_i2c_ctrl_p inst, param_pins, const int chip_addr, const int check_ack)
     
208. {
     
209.         memset(inst, 0, sizeof *inst);
     
210.        
     
211.         inst->sda_pin = sda_pin;
     
212.         inst->scl_pin = scl_pin;
     
213.         inst->chip_addr = chip_addr;
     
214.         inst->check_ack = check_ack;
     
215. }
     
216. 
     
217. int ssd1306_i2c_send_command(ssd1306_i2c_ctrl_p inst, const int command)
     
218. {
     
219.         int num_ack = 0;
     
220.         const int sda_pin = inst->sda_pin;
     
221.         const int scl_pin = inst->scl_pin;
     
222.        
     
223.         // start condition
     
224.         _i2c_start(i2c_pin);
     
225.        
     
226.         // address & R/W bit (write => 0)
     
227.         _i2c_write_byte(i2c_pin, (inst->chip_addr << 1));
     
228.        
     
229.         // ACK
     
230.         pinMode(sda_pin, INPUT);
     
231.         if(_i2c_read_bit(i2c_pin)){if(inst->check_ack)return 0;}else num_ack ++;
     
232.        
     
233.         // control bvte
     
234.         _i2c_write_byte(i2c_pin, 0x00);
     
235.        
     
236.         // ACK
     
237.         pinMode(sda_pin, INPUT);
     
238.         if(_i2c_read_bit(i2c_pin)){if(inst->check_ack)return 0;}else num_ack ++;
     
239.        
     
240.         // command
     
241.         _i2c_write_byte(i2c_pin, command);
     
242.        
     
243.         // ACK
     
244.         pinMode(sda_pin, INPUT);
     
245.         if(_i2c_read_bit(i2c_pin)){if(inst->check_ack)return 0;}else num_ack ++;
     
246.        
     
247.         // stop condition
     
248.         _i2c_stop(i2c_pin);
     
249.         return num_ack;
     
250. }
     
251. 
     
252. int ssd1306_i2c_send_data(ssd1306_i2c_ctrl_p inst, const void *data, const size_t cb_data)
     
253. {
     
254.         int num_ack = 0;
     
255.         const uint8_t *ptr = data;
     
256.         size_t counter = cb_data;
     
257.         const int sda_pin = inst->sda_pin;
     
258.         const int scl_pin = inst->scl_pin;
     
259.        
     
260.         // start condition
     
261.         _i2c_start(i2c_pin);
     
262.        
     
263.         // address & R/W bit (write => 0)
     
264.         _i2c_write_byte(i2c_pin, (inst->chip_addr << 1));
     
265.        
     
266.         // ACK
     
267.         pinMode(sda_pin, INPUT);
     
268.         if(_i2c_read_bit(i2c_pin)){if(inst->check_ack)return 0;}else num_ack ++;
     
269.        
     
270.         // control bvte
     
271.         _i2c_write_byte(i2c_pin, 0x40);
     
272.        
     
273.         // ACK
     
274.         pinMode(sda_pin, INPUT);
     
275.         if(_i2c_read_bit(i2c_pin)){if(inst->check_ack)return 0;}else num_ack ++;
     
276.        
     
277.        
     
278.         while(counter--)
     
279.         {
     
280.                 // data
     
281.                 _i2c_write_byte(i2c_pin, *ptr++);
     
282.                
     
283.                 // ACK
     
284.                 pinMode(sda_pin, INPUT);
     
285.                 if(_i2c_read_bit(i2c_pin)){if(inst->check_ack)return 0;}else num_ack ++;
     
286.         }
     
287.        
     
288.         // stop condition
     
289.         _i2c_stop(i2c_pin);
     
290.         return num_ack;
     
291. }
     
292. 
     
293. int ssd1306_i2c_fill(ssd1306_i2c_ctrl_p inst, const uint8_t val, const size_t cb_len)
     
294. {
     
295.         int num_ack = 0;
     
296.         size_t counter = cb_len;
     
297.         const int sda_pin = inst->sda_pin;
     
298.         const int scl_pin = inst->scl_pin;
     
299.        
     
300.         // start condition
     
301.         _i2c_start(i2c_pin);
     
302.        
     
303.         // address & R/W bit (write => 0)
     
304.         _i2c_write_byte(i2c_pin, (inst->chip_addr << 1));
     
305.        
     
306.         // ACK
     
307.         pinMode(sda_pin, INPUT);
     
308.         if(_i2c_read_bit(i2c_pin)){if(inst->check_ack)return 0;}else num_ack ++;
     
309.        
     
310.         // control bvte
     
311.         _i2c_write_byte(i2c_pin, 0x40);
     
312.        
     
313.         // ACK
     
314.         pinMode(sda_pin, INPUT);
     
315.         if(_i2c_read_bit(i2c_pin)){if(inst->check_ack)return 0;}else num_ack ++;
     
316.        
     
317.         while(counter--)
     
318.         {
     
319.                 // data
     
320.                 _i2c_write_byte(i2c_pin, val);
     
321.                
     
322.                 // ACK
     
323.                 pinMode(sda_pin, INPUT);
     
324.                 if(_i2c_read_bit(i2c_pin)){if(inst->check_ack)return 0;}else num_ack ++;
     
325.         }
     
326.        
     
327.         // stop condition
     
328.         _i2c_stop(i2c_pin);
     
329.         return num_ack;
     
330. }
     
331. 
     
332. int ssd1306_i2c_boot(ssd1306_i2c_ctrl_p inst)
     
333. {
     
334.         int num_ack = 0;
     
335.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_DISPLAYOFF);
     
336.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_SETDISPLAYCLOCKDIV);
     
337.         num_ack += ssd1306_i2c_send_command(inst, 0xF0);
     
338.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_SETMULTIPLEX);
     
339.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_LCDHEIGHT - 1);
     
340.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_SETDISPLAYOFFSET);
     
341.         num_ack += ssd1306_i2c_send_command(inst, 0);
     
342.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_SETSTARTLINE | 0);
     
343.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_CHARGEPUMP);
     
344.         num_ack += ssd1306_i2c_send_command(inst, 0x14);
     
345.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_MEMORYMODE);
     
346.         num_ack += ssd1306_i2c_send_command(inst, 0);
     
347.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_SEGREMAP | 0x1);
     
348.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_COMSCANDEC);
     
349.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_SETCOMPINS);
     
350.         num_ack += ssd1306_i2c_send_command(inst, 0x12);
     
351.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_SETCONTRAST);
     
352.         num_ack += ssd1306_i2c_send_command(inst, 0xCF);
     
353.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_SETPRECHARGE);
     
354.         num_ack += ssd1306_i2c_send_command(inst, 0xF1);
     
355.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_SETVCOMDETECT);
     
356.         num_ack += ssd1306_i2c_send_command(inst, 0x40);
     
357.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_DISPLAYALLON_RESUME);
     
358.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_NORMALDISPLAY);
     
359.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_DEACTIVATE_SCROLL);
     
360.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_DISPLAYON);
     
361.        
     
362.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_COLUMNADDR);
     
363.         num_ack += ssd1306_i2c_send_command(inst, 0);
     
364.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_LCDWIDTH - 1);
     
365.         num_ack += ssd1306_i2c_send_command(inst, SSD1306_PAGEADDR);
     
366.         num_ack += ssd1306_i2c_send_command(inst, 0); // Page start address (0 = reset)
     
367. #if SSD1306_LCDHEIGHT == 64
     
368.         num_ack += ssd1306_i2c_send_command(inst, 7); // Page end address
     
369. #endif
     
370. #if SSD1306_LCDHEIGHT == 32
     
371.         num_ack += ssd1306_i2c_send_command(inst, 3); // Page end address
     
372. #endif
     
373. #if SSD1306_LCDHEIGHT == 16
     
374.         num_ack += ssd1306_i2c_send_command(inst, 1); // Page end address
     
375. #endif
     
376.         return num_ack;
     
377. }
     
378. 
     
379. int ssd1306_i2c_cls(ssd1306_i2c_ctrl_p inst)
     
380. {
     
381.         return ssd1306_i2c_fill(inst, 0, SSD1306_LCDWIDTH * SSD1306_LCDHEIGHT / 8);
     
382. }
     
383. 
     
384. #include"font8x8.h"
     
385. 
     
386. int ssd1306_i2c_putchar(ssd1306_i2c_ctrl_p inst, const int ch)
     
387. {
     
388.         int v = ch - 1;
     
389.         if(v >= 0x7F)v = 0;
     
390.         return ssd1306_i2c_send_data(inst, &ascii8x8_vert[v * 8], 8);
     
391. }
     
392. 
     
393. void ssd1306_i2c_printf(ssd1306_i2c_ctrl_p inst, const char *format, ...)
     
394. {
     
395.         va_list ap;
     
396.         char buf[4096];
     
397.         int i;
     
398.        
     
399.         va_start(ap, format);
     
400.        
     
401.         vsnprintf(buf, sizeof buf, format, ap);
     
402.        
     
403.         for(i = 0; i < sizeof buf; i++)
     
404.         {
     
405.                 if(!buf[i])
     
406.                         break;
     
407.                 if(buf[i] >= 0x20)
     
408.                         ssd1306_i2c_putchar(inst, buf[i]);
     
409.         }
     
410.        
     
411.         va_end(ap);
     
412. }
     
413. 
     
414. #define I2C_GPIO_PIN 9, 8
     
415. 
     
416. int main()
     
417. {
     
418.         wiringPiSetup();
     
419.        
     
420.         ssd1306_i2c_ctrl_t ssd1306;
     
421.        
     
422.         ssd1306_i2c_init(&ssd1306, I2C_GPIO_PIN, SSD1306_I2C_ADDRESS, ignore_nack);
     
423.         ssd1306_i2c_boot(&ssd1306);
     
424.         ssd1306_i2c_cls(&ssd1306);
     
425.        
     
426.         ssd1306_i2c_printf(&ssd1306, "Hello motherfucker ");
     
427.        
     
428.        
     
429.         sleep(1);
     
430.        
     
431.         //printf("%d\n", ssd1306_i2c_send_command(&ssd1306, SSD1306_DISPLAYOFF));
     
432.        
     
433.         return 0;
     
434. }

复制代码

0xAA55

点阵字体：

1. const unsigned char ascii8x8_vert[] =
   
2. {
   
3.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
   
4.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
   
5.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
   
6.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
   
7.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
   
8.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
   
9.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
   
10.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
11.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
12.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
13.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
14.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
15.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
16.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
17.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
18.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
19. 
    
20.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
21.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
22.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
23.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
24.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
25.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
26.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
27.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
28.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
29.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
30.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
31.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
32.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
33.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
34.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00,
    
35.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //  
    
36. 
    
37.         0x00,0x00,0x00,0x00,0x2F,0x00,0x00,0x00, // !
    
38.         0x00,0x00,0x03,0x00,0x03,0x00,0x00,0x00, // "
    
39.         0x00,0x14,0x3E,0x14,0x3E,0x14,0x00,0x00, // #
    
40.         0x00,0x00,0x24,0x2A,0x7F,0x2A,0x12,0x00, // $
    
41.         0x02,0x05,0x15,0x0A,0x14,0x2A,0x28,0x10, // %
    
42.         0x00,0x00,0x16,0x29,0x29,0x11,0x10,0x28, // &
    
43.         0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00, // '
    
44.         0x00,0x00,0x0C,0x12,0x21,0x00,0x00,0x00, // (
    
45.         0x00,0x00,0x00,0x21,0x12,0x0C,0x00,0x00, // )
    
46.         0x00,0x00,0x15,0x0E,0x1F,0x0E,0x15,0x00, // *
    
47.         0x00,0x00,0x08,0x08,0x3E,0x08,0x08,0x00, // +
    
48.         0x00,0x00,0x00,0x40,0x20,0x00,0x00,0x00, // ,
    
49.         0x00,0x00,0x08,0x08,0x08,0x08,0x00,0x00, // -
    
50.         0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00, // .
    
51.         0x00,0x20,0x10,0x08,0x04,0x02,0x01,0x00, // /
    
52.         0x00,0x0C,0x12,0x21,0x21,0x12,0x0C,0x00, // 0
    
53. 
    
54.         0x00,0x00,0x00,0x22,0x3F,0x20,0x00,0x00, // 1
    
55.         0x00,0x22,0x31,0x29,0x29,0x25,0x22,0x00, // 2
    
56.         0x00,0x12,0x21,0x29,0x29,0x25,0x12,0x00, // 3
    
57.         0x00,0x18,0x14,0x12,0x3F,0x10,0x00,0x00, // 4
    
58.         0x00,0x17,0x25,0x25,0x25,0x25,0x19,0x00, // 5
    
59.         0x00,0x1E,0x25,0x25,0x25,0x25,0x18,0x00, // 6
    
60.         0x00,0x21,0x11,0x09,0x05,0x03,0x01,0x00, // 7
    
61.         0x00,0x1A,0x25,0x25,0x25,0x25,0x1A,0x00, // 8
    
62.         0x00,0x06,0x29,0x29,0x29,0x29,0x1E,0x00, // 9
    
63.         0x00,0x00,0x00,0x00,0x24,0x00,0x00,0x00, // :
    
64.         0x00,0x00,0x00,0x40,0x24,0x00,0x00,0x00, // ;
    
65.         0x00,0x08,0x08,0x14,0x14,0x22,0x22,0x00, // <
    
66.         0x00,0x14,0x14,0x14,0x14,0x14,0x14,0x00, // =
    
67.         0x00,0x22,0x22,0x14,0x14,0x08,0x08,0x00, // >
    
68.         0x00,0x02,0x01,0x29,0x09,0x06,0x00,0x00, // ?
    
69.         0x18,0x24,0x42,0xBA,0xAA,0xBE,0x00,0x00, // @
    
70. 
    
71.         0x00,0x30,0x0C,0x0B,0x0B,0x0C,0x30,0x00, // A
    
72.         0x00,0x3F,0x25,0x25,0x25,0x1A,0x00,0x00, // B
    
73.         0x0C,0x12,0x21,0x21,0x21,0x12,0x00,0x00, // C
    
74.         0x00,0x3F,0x21,0x21,0x21,0x1E,0x00,0x00, // D
    
75.         0x00,0x3F,0x25,0x25,0x25,0x21,0x00,0x00, // E
    
76.         0x00,0x3F,0x05,0x05,0x05,0x01,0x00,0x00, // F
    
77.         0x0C,0x12,0x21,0x29,0x29,0x1A,0x00,0x00, // G
    
78.         0x00,0x3F,0x04,0x04,0x04,0x04,0x3F,0x00, // H
    
79.         0x00,0x00,0x21,0x21,0x3F,0x21,0x21,0x00, // I
    
80.         0x00,0x10,0x20,0x21,0x21,0x1F,0x00,0x00, // J
    
81.         0x00,0x3F,0x08,0x0C,0x12,0x21,0x00,0x00, // K
    
82.         0x00,0x3F,0x20,0x20,0x20,0x20,0x20,0x00, // L
    
83.         0x00,0x3F,0x02,0x04,0x08,0x04,0x02,0x3F, // M
    
84.         0x00,0x3F,0x02,0x04,0x08,0x10,0x3F,0x00, // N
    
85.         0x00,0x00,0x1E,0x21,0x21,0x21,0x1E,0x00, // O
    
86.         0x00,0x3F,0x05,0x05,0x05,0x02,0x00,0x00, // P
    
87. 
    
88.         0x00,0x00,0x1E,0x21,0x21,0x21,0x5E,0x00, // Q
    
89.         0x00,0x3F,0x05,0x0D,0x15,0x22,0x00,0x00, // R
    
90.         0x00,0x00,0x12,0x25,0x29,0x29,0x12,0x00, // S
    
91.         0x00,0x01,0x01,0x01,0x3F,0x01,0x01,0x01, // T
    
92.         0x00,0x1F,0x20,0x20,0x20,0x20,0x1F,0x00, // U
    
93.         0x01,0x06,0x18,0x20,0x20,0x18,0x06,0x01, // V
    
94.         0x00,0x3F,0x10,0x08,0x04,0x08,0x10,0x3F, // W
    
95.         0x00,0x21,0x12,0x0C,0x0C,0x12,0x21,0x00, // X
    
96.         0x00,0x01,0x02,0x04,0x38,0x04,0x02,0x01, // Y
    
97.         0x00,0x21,0x31,0x29,0x25,0x23,0x21,0x00, // Z
    
98.         0x00,0x00,0x3F,0x21,0x21,0x00,0x00,0x00, // [
    
99.         0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x00, // \ bs
    
100.         0x00,0x00,0x21,0x21,0x3F,0x00,0x00,0x00, // ]
     
101.         0x00,0x00,0x02,0x01,0x02,0x00,0x00,0x00, // ^
     
102.         0x00,0x20,0x20,0x20,0x20,0x20,0x20,0x00, // _
     
103.         0x00,0x00,0x00,0x01,0x02,0x00,0x00,0x00, // `
     
104. 
     
105.         0x00,0x10,0x2A,0x2A,0x2A,0x1A,0x3C,0x00, // a
     
106.         0x00,0x3F,0x14,0x24,0x24,0x24,0x18,0x00, // b
     
107.         0x00,0x00,0x18,0x24,0x24,0x24,0x00,0x00, // c
     
108.         0x00,0x18,0x24,0x24,0x24,0x14,0x3F,0x00, // d
     
109.         0x00,0x1C,0x2A,0x2A,0x2A,0x2A,0x0C,0x00, // e
     
110.         0x00,0x00,0x08,0x3E,0x0A,0x00,0x00,0x00, // f
     
111.         0x00,0x18,0xA4,0xA4,0x88,0x7C,0x00,0x00, // g
     
112.         0x00,0x00,0x3F,0x04,0x04,0x38,0x00,0x00, // h
     
113.         0x00,0x00,0x00,0x00,0x3D,0x00,0x00,0x00, // i
     
114.         0x00,0x80,0x80,0x84,0x7D,0x00,0x00,0x00, // j
     
115.         0x00,0x00,0x3F,0x10,0x28,0x24,0x00,0x00, // k
     
116.         0x00,0x00,0x00,0x3F,0x20,0x00,0x00,0x00, // l
     
117.         0x00,0x3C,0x04,0x08,0x08,0x04,0x3C,0x00, // m
     
118.         0x00,0x00,0x3C,0x08,0x04,0x04,0x3C,0x00, // n
     
119.         0x00,0x18,0x24,0x24,0x24,0x24,0x18,0x00, // o
     
120.         0x00,0xFC,0x28,0x24,0x24,0x24,0x18,0x00, // p
     
121. 
     
122.         0x00,0x18,0x24,0x24,0x24,0x28,0xFC,0x00, // q
     
123.         0x00,0x00,0x3C,0x08,0x04,0x04,0x08,0x00, // r
     
124.         0x00,0x00,0x24,0x2A,0x2A,0x12,0x00,0x00, // s
     
125.         0x00,0x00,0x04,0x3E,0x24,0x04,0x00,0x00, // t
     
126.         0x00,0x00,0x1C,0x20,0x20,0x10,0x3C,0x00, // u
     
127.         0x00,0x0C,0x10,0x20,0x20,0x10,0x0C,0x00, // v
     
128.         0x0C,0x30,0x20,0x10,0x10,0x20,0x30,0x0C, // w
     
129.         0x00,0x24,0x28,0x10,0x10,0x28,0x24,0x00, // x
     
130.         0x00,0x84,0x88,0x50,0x20,0x10,0x0C,0x00, // y
     
131.         0x00,0x00,0x24,0x34,0x2C,0x24,0x00,0x00, // z
     
132.         0x00,0x00,0x0C,0x3F,0x21,0x21,0x00,0x00, // {
     
133.         0x00,0x00,0x00,0x00,0x7F,0x00,0x00,0x00, // |
     
134.         0x00,0x00,0x21,0x21,0x3F,0x0C,0x00,0x00, // }
     
135.         0x00,0x10,0x08,0x08,0x10,0x10,0x08,0x00, // ~
     
136.         0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x00, // 
     
137.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //
     
138. };

复制代码

Ayala

与硬件同步交互在使用延迟时要尽量避免使用 yield 延迟，如果需要使用延迟首先选择“计数锁”

0xAA55

Ayala 发表于 2017-11-19 19:31
与硬件同步交互在使用延迟时要尽量避免使用 yield 延迟，如果需要使用延迟首先选择“计数锁” ...

主要是不想忙等待

Ayala

0xAA55 发表于 2017-11-19 22:30
主要是不想忙等待

处理器和硬件交互 经常需要忙等 就算目标硬件控制器支持队列 也很多时候需要等待几tsc 或者等待几晶刻

0xAA55

我才不会说这是因为我不会配置香蕉派的WiringPi外设驱动，才强行写GPIO