直接操作Framebuffer测试液晶屏

自己写的一个液晶屏测试小程序，直接写frambuffer，总共四幅画面，如下所示：

程序很简单，就是进行内存映射之后写frambuffer。这个程序是在华清远见的一个程序上改的，目前只支持16BPP的液晶屏。代码如下：

[cpp]  view plain copy print ?

1. #include <unistd.h>  
2. #include <stdlib.h>  
3. #include <stdio.h>  
4. #include <fcntl.h>  
5. #include <linux/fb.h>  
6. #include <sys/mman.h>  
7.   
8. int main(int argc, char *argv[])  
9. {  
10.     int fbfd = 0;  
11.     struct fb_var_screeninfo vinfo;  
12.     unsigned long screensize = 0;  
13.     unsigned long location = 0;  
14.     char *fbp = 0;  
15.     int x = 0, y = 0;  
16.     int seg_len = 0;  
17.     int tmp_seg_len = 0;  
18.     int seg_num = 0;  
19.     unsigned short rgb = 0;  
20.     unsigned int r = 0, g = 0, b = 0;  
21.   
22.     // Open the file for reading and writing  
23.     fbfd = open("/dev/fb0", O_RDWR);  
24.     if (!fbfd) {  
25.         printf("Error: cannot open framebuffer device.\n");  
26.         exit(1);  
27.     }  
28.     printf("The framebuffer device was opened successfully.\n");  
29.   
30.     // Get variable screen information  
31.     if (ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo)) {  
32.         printf("Error reading variable information.\n");  
33.         exit(1);  
34.     }  
35.   
36.     printf("%dx%d, %dbpp\n", vinfo.xres, vinfo.yres, vinfo.bits_per_pixel);  
37.     if (vinfo.bits_per_pixel != 16) {  
38.         printf("Error: not supported bits_per_pixel, it only supports 16 bit color\n");  
39.         exit(1);  
40.     }  
41.   
42.     // Figure out the size of the screen in bytes  
43.     screensize = vinfo.xres * vinfo.yres * 2;  
44.   
45.     // Map the device to memory  
46.     fbp = (char *)mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED,  
47.         fbfd, 0);  
48.     if ((int)fbp == -1) {  
49.         printf("Error: failed to map framebuffer device to memory.\n");  
50.         exit(4);  
51.     }  
52.     printf("The framebuffer device was mapped to memory successfully.\n");  
53.   
54.     seg_len = vinfo.yres/6;  
55. #if 1  
56.     seg_len = vinfo.yres/6;  
57.     for (seg_num = 0; seg_num < 6; seg_num++) {  
58.         if (seg_num == 5)   
59.             tmp_seg_len = vinfo.yres - seg_len*5;  
60.         else   
61.             tmp_seg_len = seg_len;  
62.           
63.         for (y = 0; y < tmp_seg_len; y++) {  
64.             for (x = 0; x < vinfo.xres; x++) {  
65.                 location = seg_num*seg_len*vinfo.xres*2 + (y*vinfo.xres+ x)*2;  
66.                 switch (seg_num) {  
67.                     case 0:  
68.                     r = 0xff;  
69.                     g = (0xff/seg_len)*y;  
70.                     b = 0;  
71.                     break;  
72.                     case 1:  
73.                     r = (0xff/seg_len)*(seg_len-y);  
74.                     g = 0xff;  
75.                     b = 0;  
76.                     break;  
77.                     case 2:  
78.                     r = 0;  
79.                     g = 0xff;  
80.                     b = (0xff/seg_len)*y;   
81.                     break;  
82.                     case 3:  
83.                     r = 0;  
84.                     g = (0xff/seg_len)*(seg_len-y);  
85.                     b = 0xff;  
86.                     break;  
87.                     case 4:  
88.                     r =  (0xff/seg_len)*y;    
89.                     g = 0;  
90.                     b = 0xff;  
91.                     break;  
92.                     case 5:  
93.                     r = 0xff;  
94.                     b = (0xff/seg_len)*(seg_len-y);   
95.                     g = 0;  
96.                     break;  
97.                     default:  
98.                     printf("%s--%d:unknown seg_num %d\n", __FILE__, __LINE__);  
99.                     break;  
100.                 }  
101.   
102.                 r = (r*0x1f)/0xff;  
103.                 g = (g*0x3f)/0xff;  
104.                 b = (b*0x1f)/0xff;  
105.                 rgb = (r << 11) | (g << 5) | b;  
106.                 *((unsigned short*)(fbp + location)) = rgb;  
107.             }  
108.         }  
109.     }  
110.       
111.     sleep(2);  
112.       
113.     seg_len = vinfo.yres/6;  
114.     for (seg_num = 0; seg_num < 6; seg_num++) {  
115.         if (seg_num == 5)   
116.             tmp_seg_len = vinfo.yres - seg_len*5;  
117.         else   
118.             tmp_seg_len = seg_len;  
119.   
120.         for (y = 0; y < tmp_seg_len; y++) {  
121.             for (x = 0; x < vinfo.xres; x++) {  
122.                 location = seg_num*seg_len*vinfo.xres*2 + (y*vinfo.xres+ x)*2;  
123.                 switch (seg_num) {  
124.                     case 0://grey  
125.                     r = 100;  
126.                     g = 100;  
127.                     b = 100;   
128.                     break;  
129.                     case 1: //black  
130.                     r = 0x00;  
131.                     g = 0x00;  
132.                     b = 0x00;  
133.                     break;  
134.                     case 2://white  
135.                     r = 0xff;  
136.                     g = 0xff;  
137.                     b = 0xff;  
138.                     break;  
139.                     case 3://red  
140.                     r = 0xff;  
141.                     g = 0;  
142.                     b = 0;  
143.                     break;  
144.                     case 4: //green  
145.                     r =  0;       
146.                     g = 0xff;  
147.                     b = 0;  
148.                     break;  
149.                     case 5: //blue  
150.                     r = 0;  
151.                     g = 0;  
152.                     b = 0xff;   
153.                     break;  
154.                     default:  
155.                     printf("%s--%d:unknown seg_num %d\n", __FILE__, __LINE__);  
156.                     break;    
157.                 }  
158.   
159.                 r = (r*0x1f)/0xff;  
160.                 g = (g*0x3f)/0xff;  
161.                 b = (b*0x1f)/0xff;  
162.                 rgb = (r << 11) | (g << 5) | b;  
163.                 *((unsigned short*)(fbp + location)) = rgb;  
164.             }  
165.         }  
166.     }  
167. #endif  
168.   
169. #if 1  
170.     sleep(2);  
171.   
172.     seg_len = vinfo.xres/6;  
173.     for (seg_num = 0; seg_num < 6; seg_num++) {    
174.         if (seg_num == 5)   
175.             tmp_seg_len = vinfo.xres - seg_len*5;  
176.         else   
177.             tmp_seg_len = seg_len;  
178.   
179.         for (x = 0; x < tmp_seg_len; x++) {  
180.             for (y = 0; y < vinfo.yres; y++) {  
181.                 location = y*vinfo.xres*2 + (seg_num*seg_len + x)*2;  
182.                   
183.                 switch (seg_num) {  
184.                     case 0:  
185.                     r = 0xff;  
186.                     g = (0xff/seg_len)*x;  
187.                     b = 0;  
188.                     break;  
189.                     case 1:  
190.                     r = (0xff/seg_len)*(seg_len-x);  
191.                     g = 0xff;  
192.                     b = 0;  
193.                     break;  
194.                     case 2:  
195.                     r = 0;  
196.                     g = 0xff;  
197.                     b = (0xff/seg_len)*x;   
198.                     break;  
199.                     case 3:  
200.                     r = 0;  
201.                     g = (0xff/seg_len)*(seg_len-x);  
202.                     b = 0xff;  
203.                     break;  
204.                     case 4:  
205.                     r =  (0xff/seg_len)*x;    
206.                     g = 0;  
207.                     b = 0xff;  
208.                     break;  
209.                     case 5:  
210.                     r = 0xff;  
211.                     g = 0;  
212.                     b = (0xff/seg_len)*(seg_len-x);   
213.                     break;  
214.                     default:  
215.                     printf("%s--%d:unknown seg_num %d\n", __FILE__, __LINE__);  
216.                     break;  
217.                 }  
218.   
219.                 r = (r*0x1f)/0xff;  
220.                 g = (g*0x3f)/0xff;  
221.                 b = (b*0x1f)/0xff;  
222.                 rgb = (r << 11) | (g << 5) | b;  
223.                 *((unsigned short*)(fbp + location)) = rgb;  
224.             }  
225.         }  
226.     }  
227.   
228.     sleep(2);  
229.   
230.     seg_len = vinfo.xres/6;  
231.     /* white black gray red green blue */  
232.     for (seg_num = 0; seg_num < 6; seg_num++) {  
233.         if (seg_num == 5)   
234.             tmp_seg_len = vinfo.xres - seg_len*5;  
235.         else   
236.             tmp_seg_len = seg_len;  
237.   
238.         for (x = 0; x < tmp_seg_len; x++) {  
239.             for (y = 0; y < vinfo.yres; y++) {  
240.                 location = y*vinfo.xres*2 + (seg_num*seg_len + x)*2;  
241.                   
242.                 switch (seg_num) {  
243.                     case 0://grey  
244.                     r = 100;  
245.                     g = 100;  
246.                     b = 100;   
247.                     break;  
248.                     case 1://black  
249.                     r = 0;  
250.                     g = 0;  
251.                     b = 0;  
252.                     break;  
253.                     case 2: //white  
254.                     r = 0xff;  
255.                     g = 0xff;  
256.                     b = 0xff;  
257.                     break;  
258.                     case 3://red  
259.                     r = 0xff;  
260.                     g = 0;  
261.                     b = 0;  
262.                     break;  
263.                     case 4: //green  
264.                     r =  0;       
265.                     g = 0xff;  
266.                     b = 0;  
267.                     break;  
268.                     case 5: //blue  
269.                     r = 0;  
270.                     g = 0;  
271.                     b = 0xff;   
272.                     break;  
273.                     default:  
274.                     printf("%s--%d:unknown seg_num %d\n", __FILE__, __LINE__);  
275.                     break;  
276.                 }  
277.                   
278.                 r = (r*0x1f)/0xff;  
279.                 g = (g*0x3f)/0xff;  
280.                 b = (b*0x1f)/0xff;  
281.                 rgb = (r << 11) | (g << 5) | b;  
282.                 *((unsigned short*)(fbp + location)) = rgb;  
283.             }  
284.         }  
285.     }  
286. #endif  
287.   
288.     munmap(fbp, screensize);  
289.     close(fbfd);  
290.     return 0;  
291. }