本帖最后由 qinyunti 于 2023-4-11 10:22 编辑

前言
基于framebuffer快速对hdmi输出进行测试，以下都是直接串口终端登录开发板，使用开发板自己的编译工具链进行编译，无需交叉编译非常方便。
代码
新建fb.c
vi fb.c
输入如下内容
  1. #include <unistd.h>
  3. #include <stdlib.h>
  5. #include <stdio.h>
  7. #include <fcntl.h>
  9. #include <linux/fb.h>
  11. #include <sys/mman.h>
  13. #include <sys/ioctl.h>
  15. #include <stdint.h>
  19. int main(int argc, char *argv[])
  21. {
  23.     int fbfd = 0;
  25.     struct fb_var_screeninfo vinfo;
  27.     unsigned long screensize = 0;
  29.     unsigned long location = 0;
  31.     char *fbp = 0;
  33.     int x = 0, y = 0;
  35.     int seg_len = 0;
  37.     int tmp_seg_len = 0;
  39.     int seg_num = 0;
  41.     uint32_t rgb = 0;
  43.     uint32_t r = 0, g = 0, b = 0;
  47.     // Open the file for reading and writing
  49.     fbfd = open("/dev/fb0", O_RDWR);
  51.     if (!fbfd) {
  53.         printf("Error: cannot open framebuffer device.\n");
  55.         exit(1);
  57.     }
  59.     printf("The framebuffer device was opened successfully.\n");
  63.     // Get variable screen information
  65.     if (ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo)) {
  67.         printf("Error reading variable information.\n");
  69.         exit(1);
  71.     }
  75.     printf("%dx%d, %dbpp\n", vinfo.xres, vinfo.yres, vinfo.bits_per_pixel);
  77.     //if (vinfo.bits_per_pixel != 16) {
  79.     //  printf("Error: not supported bits_per_pixel, it only supports 16 bit color\n");
  81.     //  exit(1);
  83.     //}
  87.     // Figure out the size of the screen in bytes
  89.     screensize = vinfo.xres * vinfo.yres * vinfo.bits_per_pixel/8;
  93.     // Map the device to memory
  95.     fbp = (char *)mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED,
  97.         fbfd, 0);
  99.     if ((int)fbp == -1) {
  101.         printf("Error: failed to map framebuffer device to memory.\n");
  103.         exit(4);
  105.     }
  107.     printf("The framebuffer device was mapped to memory successfully.\n");
  111.     seg_len = vinfo.yres/6;
  113. #if 1
  115.     seg_len = vinfo.yres/6;
  117.     for (seg_num = 0; seg_num < 6; seg_num++) {
  119.         if (seg_num == 5)
  121.             tmp_seg_len = vinfo.yres - seg_len*5;
  123.         else
  125.             tmp_seg_len = seg_len;
  127.       
  129.         for (y = 0; y < tmp_seg_len; y++) {
  131.             for (x = 0; x < vinfo.xres; x++) {
  133.                 location = seg_num*seg_len*vinfo.xres*vinfo.bits_per_pixel/8 + (y*vinfo.xres+ x)*vinfo.bits_per_pixel/8;
  135.                 switch (seg_num) {
  137.                     case 0:
  139.                     r = 0xff;
  141.                     g = (0xff/seg_len)*y;
  143.                     b = 0;
  145.                     break;
  147.                     case 1:
  149.                     r = (0xff/seg_len)*(seg_len-y);
  151.                     g = 0xff;
  153.                     b = 0;
  155.                     break;
  157.                     case 2:
  159.                     r = 0;
  161.                     g = 0xff;
  163.                     b = (0xff/seg_len)*y;
  165.                     break;
  167.                     case 3:
  169.                     r = 0;
  171.                     g = (0xff/seg_len)*(seg_len-y);
  173.                     b = 0xff;
  175.                     break;
  177.                     case 4:
  179.                     r =  (0xff/seg_len)*y;  
  181.                     g = 0;
  183.                     b = 0xff;
  185.                     break;
  187.                     case 5:
  189.                     r = 0xff;
  191.                     b = (0xff/seg_len)*(seg_len-y);
  193.                     g = 0;
  195.                     break;
  197.                     default:
  199.                     printf("%s--%d:unknown seg_num %d\n", __FILE__, __LINE__);
  201.                     break;
  203.                 }
  207.                 if(vinfo.bits_per_pixel == 16)
  209.                 {
  211.                     r = (r*0x1f)/0xff;
  213.                     g = (g*0x3f)/0xff;
  215.                     b = (b*0x1f)/0xff;
  217.                     rgb = (r << 11) | (g << 5) | b;
  219.                     *((uint16_t*)(fbp + location)) = rgb;
  221.                 }
  223.                 else
  225.                 {
  227.                     rgb = (r << 16) | (g << 8) | b;
  229.                     *((uint32_t*)(fbp + location)) = rgb;
  231.                 }
  233.             }
  235.         }
  237.     }
  239.    
  241.     sleep(2);
  243.    
  245.     seg_len = vinfo.yres/6;
  247.     for (seg_num = 0; seg_num < 6; seg_num++) {
  249.         if (seg_num == 5)
  251.             tmp_seg_len = vinfo.yres - seg_len*5;
  253.         else
  255.             tmp_seg_len = seg_len;
  259.         for (y = 0; y < tmp_seg_len; y++) {
  261.             for (x = 0; x < vinfo.xres; x++) {
  263.                 location = seg_num*seg_len*vinfo.xres*vinfo.bits_per_pixel/8 + (y*vinfo.xres+ x)*vinfo.bits_per_pixel/8;
  265.                 switch (seg_num) {
  267.                     case 0://grey
  269.                     r = 100;
  271.                     g = 100;
  273.                     b = 100;
  275.                     break;
  277.                     case 1: //black
  279.                     r = 0x00;
  281.                     g = 0x00;
  283.                     b = 0x00;
  285.                     break;
  287.                     case 2://white
  289.                     r = 0xff;
  291.                     g = 0xff;
  293.                     b = 0xff;
  295.                     break;
  297.                     case 3://red
  299.                     r = 0xff;
  301.                     g = 0;
  303.                     b = 0;
  305.                     break;
  307.                     case 4: //green
  309.                     r =  0;   
  311.                     g = 0xff;
  313.                     b = 0;
  315.                     break;
  317.                     case 5: //blue
  319.                     r = 0;
  321.                     g = 0;
  323.                     b = 0xff;
  325.                     break;
  327.                     default:
  329.                     printf("%s--%d:unknown seg_num %d\n", __FILE__, __LINE__);
  331.                     break;  
  333.                 }
  335.                 if(vinfo.bits_per_pixel == 16)
  337.                 {
  339.                     r = (r*0x1f)/0xff;
  341.                     g = (g*0x3f)/0xff;
  343.                     b = (b*0x1f)/0xff;
  345.                     rgb = (r << 11) | (g << 5) | b;
  347.                     *((uint16_t*)(fbp + location)) = rgb;
  349.                 }
  351.                 else
  353.                 {
  355.                     rgb = (r << 16) | (g << 8) | b;
  357.                     *((uint32_t*)(fbp + location)) = rgb;
  359.                 }
  361.             }
  363.         }
  365.     }
  367. #endif
  371. #if 1
  373.     sleep(2);
  377.     seg_len = vinfo.xres/6;
  379.     for (seg_num = 0; seg_num < 6; seg_num++) {
  381.         if (seg_num == 5)
  383.             tmp_seg_len = vinfo.xres - seg_len*5;
  385.         else
  387.             tmp_seg_len = seg_len;
  391.         for (x = 0; x < tmp_seg_len; x++) {
  393.             for (y = 0; y < vinfo.yres; y++) {
  395.                 location = y*vinfo.xres*vinfo.bits_per_pixel/8 + (seg_num*seg_len + x)*vinfo.bits_per_pixel/8;
  397.                
  399.                 switch (seg_num) {
  401.                     case 0:
  403.                     r = 0xff;
  405.                     g = (0xff/seg_len)*x;
  407.                     b = 0;
  409.                     break;
  411.                     case 1:
  413.                     r = (0xff/seg_len)*(seg_len-x);
  415.                     g = 0xff;
  417.                     b = 0;
  419.                     break;
  421.                     case 2:
  423.                     r = 0;
  425.                     g = 0xff;
  427.                     b = (0xff/seg_len)*x;
  429.                     break;
  431.                     case 3:
  433.                     r = 0;
  435.                     g = (0xff/seg_len)*(seg_len-x);
  437.                     b = 0xff;
  439.                     break;
  441.                     case 4:
  443.                     r =  (0xff/seg_len)*x;  
  445.                     g = 0;
  447.                     b = 0xff;
  449.                     break;
  451.                     case 5:
  453.                     r = 0xff;
  455.                     g = 0;
  457.                     b = (0xff/seg_len)*(seg_len-x);
  459.                     break;
  461.                     default:
  463.                     printf("%s--%d:unknown seg_num %d\n", __FILE__, __LINE__);
  465.                     break;
  467.                 }
  469.                 if(vinfo.bits_per_pixel == 16)
  471.                 {
  473.                     r = (r*0x1f)/0xff;
  475.                     g = (g*0x3f)/0xff;
  477.                     b = (b*0x1f)/0xff;
  479.                     rgb = (r << 11) | (g << 5) | b;
  481.                     *((uint16_t*)(fbp + location)) = rgb;
  483.                 }
  485.                 else
  487.                 {
  489.                     rgb = (r << 16) | (g << 8) | b;
  491.                     *((uint32_t*)(fbp + location)) = rgb;
  493.                 }
  495.             }
  497.         }
  499.     }
  503.     sleep(2);
  507.     seg_len = vinfo.xres/6;
  509.     /* white black gray red green blue */
  511.     for (seg_num = 0; seg_num < 6; seg_num++) {
  513.         if (seg_num == 5)
  515.             tmp_seg_len = vinfo.xres - seg_len*5;
  517.         else
  519.             tmp_seg_len = seg_len;
  523.         for (x = 0; x < tmp_seg_len; x++) {
  525.             for (y = 0; y < vinfo.yres; y++) {
  527.                 location = y*vinfo.xres*vinfo.bits_per_pixel/8 + (seg_num*seg_len + x)*vinfo.bits_per_pixel/8;
  529.                
  531.                 switch (seg_num) {
  533.                     case 0://grey
  535.                     r = 100;
  537.                     g = 100;
  539.                     b = 100;
  541.                     break;
  543.                     case 1://black
  545.                     r = 0;
  547.                     g = 0;
  549.                     b = 0;
  551.                     break;
  553.                     case 2: //white
  555.                     r = 0xff;
  557.                     g = 0xff;
  559.                     b = 0xff;
  561.                     break;
  563.                     case 3://red
  565.                     r = 0xff;
  567.                     g = 0;
  569.                     b = 0;
  571.                     break;
  573.                     case 4: //green
  575.                     r =  0;   
  577.                     g = 0xff;
  579.                     b = 0;
  581.                     break;
  583.                     case 5: //blue
  585.                     r = 0;
  587.                     g = 0;
  589.                     b = 0xff;
  591.                     break;
  593.                     default:
  595.                     printf("%s--%d:unknown seg_num %d\n", __FILE__, __LINE__);
  597.                     break;
  599.                 }
  601.                
  603.                 if(vinfo.bits_per_pixel == 16)
  605.                 {
  607.                     r = (r*0x1f)/0xff;
  609.                     g = (g*0x3f)/0xff;
  611.                     b = (b*0x1f)/0xff;
  613.                     rgb = (r << 11) | (g << 5) | b;
  615.                     *((uint16_t*)(fbp + location)) = rgb;
  617.                 }
  619.                 else
  621.                 {
  623.                     rgb = (r << 16) | (g << 8) | b;
  625.                     *((uint32_t*)(fbp + location)) = rgb;
  627.                 }
  629.             }
  631.         }
  633.     }
  635. #endif
  639.     munmap(fbp, screensize);
  641.     close(fbfd);
  643.     return 0;
  645. }
编译
gcc -o3 fb.c -o fb
运行
先登录桌面wetson,桌面终端中输入init 1,关闭图形桌面
(串口终端中输入init 5可恢复桌面）
./fb
image.png
效果如下
image.png