✌Linux Frame Buffer(Linux 底层的帧缓冲设备)

已于 2024-03-27 18:48:42 修改
阅读量1k 收藏 23
点赞数 17
分类专栏： 文件IO 文章标签： linux
于 2024-03-05 21:32:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68915288/article/details/136484040
版权

Linux Frame Buffer(Linux 底层的帧缓冲设备)
        可以显示一帧一帧的图像(屏幕的显示)

1. 基本操作

帧缓冲是Linux系统为显示设备提供的一个接口,把显示设备抽象成一个设备文件,它可以让上层的图像应用程序不需要关心具体的硬件实现细节,上层的图像应用程序只需要操作对应的"文件",往文件中写入"数据",经过帧缓冲驱动,就可以在硬件设备(LCD)上面显示对应的图像  
如何让LCD设备显示颜色呢?
        Linux中一切都是文件,只需要利用文件IO的接口去操作LCD设备就可以了
操作文件的大概步骤:
        open 
        read/write 
        close 
操作文件的时候需要知道文件名:
        lcd的文件名  "/dev/fb0"   是一个绝对路径

                linux把LCD这种硬件设备抽象成  Frame  Buffer（帧缓冲设备）

Lcd上图像的显示,本质上是由一个一个的像素点组成的
        像素点：可以描述一个点的颜色
        将LCD上面每一个像素点"描绘"成不同的颜色,就可以显示一副图画

分辨率（描述屏幕的像素点信息）：分辨率决定了位图细节的精细程度，通常情况下，分辨率越高包含的像素就越高，图像就越清晰

                6818开发板   800 * 480

                有480行，每一行有800个像素点

                可以通过函数获取

颜色的组成：RGB三基(原)色

        世界上所有的颜色都是由RGB合成的，每一个基色的比重不一样就会合成不同的颜色
        每一个基色使用一个byte(8bits)表示,给基色中的每一个bit赋为不同的值,就可以表示不同的颜色
            问题:
                一个基色可以表示多少种颜色?   0~255 ------>256
                        8个bit的值不同,就可以表示不同的颜色 
                三个基色可以表示多少种颜色?   2^24 ------>1670万种
                        24个bit的值不同,就可以表示不同的颜色 

        LCD上面一个像素点的表示: ARGB      A：透明度(1byte)
                在LCD上面一个像素点使用几个字节表示?   4byte
                使用4byte就可以表示一个像素点的颜色
    
如果使用一种数据类型来表示一个像素点的颜色,可以使用什么数据类型?
        int  刚好4个字节
        int color; // color就是一个int类型的变量,占用4byte
        给color赋值为不同的值,color就表示不同的颜色

        

        使用RGB颜色查询对照表查找你所需要的颜色：

                红色: 0x00FF0000
                绿色: 0x0000FF00
                蓝色: 0x000000FF
                黑色: 0x0
                白色: 0x00FFFFFF

只需要把颜色数据写入到屏幕对应的文件中,就可以让屏幕显示对应的颜色
            像素点在"文件"中的排列顺序是从上至下,从左至右
            理论上就可以通过文件去操作屏幕上面每一个像素点的颜色

屏幕上有多少个像素点：800*480
每一行有800个像素点,有480行

写一个简单的代码,让开发板显示对应的颜色
        打开屏幕------->(只能用系统IO打开，因为标准IO只能操作"普通文件")

                // 获取屏幕信息（分辨率，颜色分量）
        写入颜色数据

                // lcd上面从上至下、从左至右每一个像素点都是独立的，每一个像素点都可以使                       用一个int类型的颜色去描述

                // 每一次操作都必须全部给一个颜色值
        关闭屏幕

注意:
        有的开发板开机就会自动运行一个iot的程序
        关闭方法:
                killall iot 
                or 
                设置 /etc/profile 文件

练习:

        1. 画一个矩形，x0 = 100, y0 = 100, w = 200, h = 200;

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    // 打开lcd屏幕
    int fd = open("/dev/fb0", O_RDWR);
    if (-1 == fd) {
        perror("open lcd faile");
        return -1;
    }

    int colour[480][800] = {0};
    for (int y = 100; y < 300; y++) {
        for (int x = 100; x < 300; x++) {
            colour[y][x] = 0xff0000; // 红色
        }
    }
    ssize_t w = write(fd, colour, 800 * 480 * 4);
    if (-1 == w) {
        perror("write lcd faile");
        // 关闭lcd屏幕
        close(fd);
        return -1;
    }

    // 关闭屏幕
    close(fd);

    return 0;
}

        2. 使用基本的文件IO操作函数,在屏幕上面显示简单的颜色
                先显示红色
                1s后(sleep(1))
                显示绿色
                1s后 
                显示蓝色

        注意光标的位置!!!

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    // 打开lcd屏幕
    int fd = open("/dev/fb0", O_RDWR);
    if (-1 == fd) {
        perror("open lcd faile");
        return -1;
    }

    // 操作lcd屏幕
    // int colour = 0xff0000; // 红色
    // for (int y = 0; y < 480; y++) {
    //     for (int x = 0; x < 800; x++) {
    //         ssize_t w = write(fd, &colour, 4);
    //         if (-1 == w) {
    //             perror("write lcd faile");
    //             // 关闭lcd屏幕
    //             close(fd);
    //             return -1;
    //         }
    //     }
    // }

    int colour[480][800] = {0};
    for (int y = 0; y < 480; y++) {
        for (int x = 0; x < 800; x++) {
            colour[y][x] = 0xff0000; // 红色
        }
    }
    ssize_t w = write(fd, colour, 800 * 480 * 4);
    if (-1 == w) {
        perror("write lcd faile");
        // 关闭lcd屏幕
        close(fd);
        return -1;
    }

    sleep(1);
    lseek(fd, SEEK_SET, 0); // 将光标移到文件开头

    for (int y = 0; y < 480; y++) {
        for (int x = 0; x < 800; x++) {
            colour[y][x] = 0x00ff00; // 绿色
        }
    }
    w = write(fd, colour, 800 * 480 * 4);
    if (-1 == w) {
        perror("write lcd faile");
        // 关闭lcd屏幕
        close(fd);
        return -1;
    }

    sleep(1);
    lseek(fd, SEEK_SET, 0); // 将光标移到文件开头

    for (int y = 0; y < 480; y++) {
        for (int x = 0; x < 800; x++) {
            colour[y][x] = 0x0000ff; // 蓝色 
        }
    }
    w = write(fd, colour, 800 * 480 * 4);
    if (-1 == w) {
        perror("write lcd faile");
        // 关闭lcd屏幕
        close(fd);
        return -1;
    }

    // 关闭屏幕
    close(fd);

    return 0;
}

2. 使用ioctl函数去获取设备信息

ioctl函数是用来对文件/设备进行除了读写以外的其他控制操作,每一个设备的控制操作都是不一样的,这些设备具体有哪些操作是由设备的驱动程序决定的

尝试自己获取(有些设备不支持)

NAME
    ioctl - control device
        控制设备(具体的操作由驱动程序决定)
        此处我们可以使用函数获取LCD屏幕的一些基本信息
SYNOPSIS
    #include <sys/ioctl.h>

int ioctl(int fd, unsigned long request, ...);

fd：文件描述符,表示你要操作哪一个设备
      
request：命令号码,在驱动实现的时候,一般会把某些特定的操作取一个命令号
        (进行什么操作),命令号的具体含义是由提供该命令号的驱动程序决定

...：可变参数,具体的操作由命令号决定
        
返回值:
    成功返回0
    失败返回-1,同时errno被设置

例子:
    如果程序需要知道帧缓冲设备的相关信息,可以使用ioctl来完成
    对于帧缓冲设备,最常用的有两条命令(/usr/include/linux/fb.h):
        #define FBIOGET_VSCREENINFO    0x4600
            返回和设备相关的可变信息
            如:帧缓冲设备的大小(宽度,高度),以及颜色显示等信息

        #define FBIOGET_FSCREENINFO    0x4602
            返回和设备相关的固定信息
            如:设备本身的一些信息,硬件加速度等信息

        两个命令号分别有对应的结构体:
        定义在内核的头文件中：/usr/include/linux/fb.h
            struct fb_var_screeninfo{}    
            和
            struct fb_fix_screeninfo{}

        获取方法:
            // 定义一个结构体用来保存即将获取到的数据
            struct fb_var_screeninfo  vinfo;      
            // 把获取到的信息保存到结构体中
            ioctl(fd, FBIOGET_VSCREENINFO, &vinfo);

    struct fb_var_screeninfo {
        __u32 xres;  // 屏幕的宽度，每一行上面的像素点个数
        __u32 yres;  // 屏幕的高度，屏幕有多少行

        __u32 xres_virtual;  /* virtual resolution */
        __u32 yres_virtual;

        __u32 xoffset;      /* offset from virtual to visible */
        __u32 yoffset;      /* resolution */

        __u32 bits_per_pixel;  // 每一个像素点占用的bit位数量
        ...
       
        struct fb_bitfield red;     // R 描述红色的信息
        struct fb_bitfield green;   // G
        struct fb_bitfield blue;    // B
        struct fb_bitfield transp;  // A
        ......
    };       

    // 描述每一个颜色分量（A,R,G,B）占用的bit的区域信息
    struct fb_bitfield {
        __u32 offset;        // 颜色位从哪一个位开始
        __u32 length;        // 这个分量占用多少个bit  
        __u32 msb_right;     // true(!0)表示最高位在右边
    };

代码实现：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/fb.h>

int main() {
    // 打开屏幕
    int fd = open("/dev/fb0", O_RDWR);
    if (-1 == fd) {
        perror("open lcd error");
        return -1;
    }

    // 获取屏幕的信息
    // 定义一个结构体用来保存即将获取到的数据
    struct fb_var_screeninfo vinfo; // 头文件：#include <linux/fb.h>       
    // 把获取到的信息保存到结构体中
    int r = ioctl(fd, FBIOGET_VSCREENINFO, &vinfo);
    if (-1 == r) {
        perror("ioctl failed");
        close(fd);
        return -1;
    }

    // 解析结构体,打印获取到的屏幕的信息
    // 分辨率
    printf("resolution: %d * %d\n", vinfo.xres, vinfo.yres);
    // 每一个像素点占用的bit数量
    printf("bits_per_pixel: %d\n", vinfo.bits_per_pixel);
    // 每一种颜色的信息
    printf("transp.offset: %d\n", vinfo.transp.offset);
    printf("transp.length: %d\n", vinfo.transp.length);
    printf("transp.msb_right: %d\n", vinfo.transp.msb_right);

    printf("red.offset: %d\n", vinfo.red.offset);
    printf("red.length: %d\n", vinfo.red.length);
    printf("red.msb_right: %d\n", vinfo.red.msb_right);

    printf("green.offset: %d\n", vinfo.green.offset);
    printf("green.length: %d\n", vinfo.green.length);
    printf("green.msb_right: %d\n", vinfo.green.msb_right);

    printf("blue.offset: %d\n", vinfo.blue.offset);
    printf("blue.length: %d\n", vinfo.blue.length);
    printf("blue.msb_right: %d\n", vinfo.blue.msb_right);

    // 关闭屏幕
    close(fd);

    return 0;
}
resolution: 800 * 480
bits_per_pixel: 32
transp.offset: 24
transp.length: 8
transp.msb_right: 0
red.offset: 16
red.length: 8
red.msb_right: 0
green.offset: 8
green.length: 8
green.msb_right: 0
blue.offset: 0
blue.length: 8
blue.msb_right: 0

3. 操作LCD屏幕的效率问题(mmap)

每一次操作屏幕的图像,都需要使用write函数
        但是write函数会直接去访问硬件资源,占用总线,效率是非常低的

        连续调用write函数，需要lseek函数的配合，write函数会改变文件的偏移量
        ========>
        内存映射,把屏幕文件映射到内存中(操作内存就相当于操作屏幕)

映射：把文件和一段内存一一对应(建立一个联系),操作文件的时候就不需要使用write函数,只需要使用指针操作对应的内存就可以了(C语言中指针可以直接操作内存),内存内容的改变会由具体的映射驱动同步到文件中去

        在LCD中,如果把屏幕映射到内存中,就不需要使用write函数了,只需要去操作映射之后的内存即可

NAME
    mmap(映射), munmap(解映射) - map or unmap files or devices into memory
SYNOPSIS
    #include <sys/mman.h>
        
mmap是把指定的文件或者设备映射到进程地址空间(堆和栈中间),应用程序就可以通过指针去
操作映射后的地址空间从而操作文件或者设备
        
void* mmap(void *addr, size_t length, int prot, int flags,
               int fd, off_t offset);
           
addr：表示映射地址,你要把文件映射到内存的哪一个位置
      一般为NULL,表示让OS自行选择一个合适的地址
           
length：表示你要映射的长度(字节),你的文件多大
            如：映射lcd.  800*480*4
            
prot：应用程序对映射之后的内存的操作权限
          PROT_EXEC   可执行
          PROT_READ   可读
          PROT_WRITE  可写
          PROT_NONE   没有如何权限
          可读可写：PROT_READ | PROT_WRITE     
           
flags：映射标记
           MAP_SHARED:共享映射,内存的改变会同时同步到文件，对其他进程可见
           MAP_PRIVATE:私有映射,映射的更新对于映射同一文件的其他进程不可见，也不
                       会传递到基础文件
            
fd：你要映射的文件的文件描述符
            
offset：偏移量,表示你要从文件的哪一个位置开始映射,一般为0,表示从文件的开头开始映射
        
返回值:
    成功返回映射之后的内存的首地址(相当于文件的开头)
    失败返回MAP_FAILED,errno被设置
---------------------------------------------------------------------------
munmap是解除内存的映射关系
int munmap(void *addr, size_t length);
            
addr：你要解映射的首地址,是mmap的返回值
          
length：你要解映射的长度

流程:
        打开文件 
        映射文件到内存
        ==============
        操作内存就是操作文件
        ==============      
        解除映射
        关闭文件  

int *plcd = (int*)mmap(NULL, 800 * 480 * 4, PROT_READ | PROT_WRITE, 
                MAP_SHARED, fd, 0);
if (plcd == MAP_FAILED) {
    perror("mmap failed");
    close(fd);
    return -1;
}

假设映射成功后,映射后的像素点在内存中的对应关系是从左至右,从上至下
        也就是说,plcd指向的位置对应屏幕上面第0行的第0个点
        plcd+1对应屏幕上面第0行的第1个点(指针做偏移,是偏移单位个指向类型的长度)

如果想要通过plcd把屏幕的第0行的第0个点设置为红色,应该如何操作?
        把0x00ff0000这个数据放到第0行的第0个点对应的内存地址
        第0行的第0个点对应的内存地址就是plcd
        *plcd = 0x00FF0000

如果想要通过plcd把屏幕的第0行的第1个点设置为红色,应该如何操作?
        把0x00ff0000这个数据放到第0行的第1个点对应的内存地址
        第0行的第1个点对应的内存地址就是(plcd+1)
        *(plcd+1) = 0x00FF0000

如果想要通过plcd把屏幕的第0行的第x个点设置为红色,应该如何操作?
        把0x00ff0000这个数据放到第0行的第x个点对应的内存地址
        第0行的第x个点对应的内存地址就是(plcd+x)
        *(plcd+x) = 0x00FF0000  

如果想要通过plcd把屏幕的第y行的第x个点设置为红色,应该如何操作?
        把0x00ff0000这个数据放到第y行的第x个点对应的内存地址
        第y行的第x个点对应的内存地址就是(plcd+800*y+x)
        *(plcd + 800 * y + x) = 0x00FF0000

我们可以通过plcd去操作屏幕上面的每一个像素点
注意：因为内存是连续的,plcd向后只能偏移800*480*4个字节有权限使用

4. lcd代码实现

lcd.h
#ifndef __LCD_H__
#define __LCD_H__

#include <stdio.h>
#include <string.h>
#include <math.h> // arm-linux-gcc *.c -lm
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/fb.h>
#include <sys/mman.h>

// 定义一个结构体,描述一个打开的文件
typedef struct lcd {
    char name[256];
    int fd; // 文件描述符
    int *plcd; // 映射之后的首地址
    int xres;
    int yres;
    int bits_per_pixel; // 每一个像素点占用的bit位数量 / 8
} lcd;

/*
    init_lcd:初始化屏幕(打开文件/映射到内存)
    name:要初始化的屏幕的路径名,把初始化后的屏幕信息保存到lp指针指向的空间
*/
void init_lcd(const char *name, lcd *lp);

/*
    close_lcd:关闭屏幕(解映射/关闭文件)
    lp:要关闭的文件
*/
void close_lcd(lcd *lp);

/*
    lcd_draw_point:能够在指定的屏幕的指定的位置显示一个指定的颜色
*/
void lcd_draw_point(lcd *lp, int x, int y, int colour);

/*
    lcd_clear:把屏幕刷成指定的颜色
*/
void lcd_clear(lcd *lp, int colour);

/*
    在屏幕上指定的位置(x,y)显示一个指定大小,指定颜色的矩形
*/
void lcd_draw_rect(lcd *lp, int x, int y, int w, int h, int colour);

/*
    在屏幕上指定的位置(x,y)显示一个指定大小,指定颜色的圆
*/
void lcd_draw_cir(lcd *lp, int x, int y, int r, int colour);

#endif
lcd.c
#include "lcd.h"

/*
    init_lcd:初始化屏幕(打开文件/映射到内存)
    name:要初始化的屏幕的路径名,把初始化后的屏幕信息保存到lp指针指向的空间
*/
void init_lcd(const char *name, lcd *lp) 
{
    strcpy(lp->name, name);

    // 打开屏幕
    lp->fd = open(name, O_RDWR);
    if (-1 == lp->fd) 
    {
        perror("open lcd failed");
        return ;
    }

    // 通过ioctl获取设备信息
    struct fb_var_screeninfo vinfo; // 定义一个结构体用来保存即将获取到的信息
    int r = ioctl(lp->fd, FBIOGET_VSCREENINFO, &vinfo);
    if (-1 == r)
    {
        perror("ioctl failed");
        close(lp->fd);
        return ;
    }
    // 分辨率
    lp->xres = vinfo.xres;
    lp->yres = vinfo.yres;
    lp->bits_per_pixel = vinfo.bits_per_pixel / 8;
    // 把屏幕映射到内存中去
    lp->plcd = mmap(NULL, (lp->xres) * (lp->yres) * (lp->bits_per_pixel), PROT_READ | PROT_WRITE, MAP_SHARED, lp->fd, 0);
    if (lp->plcd == MAP_FAILED) 
    {
        perror("mmap error");
        close(lp->fd);
        return ;
    }
}

/*
    close_lcd:关闭屏幕(解映射/关闭文件)
    lp:要关闭的文件
*/
void close_lcd(lcd *lp) 
{
    // 解映射
    munmap(lp->plcd, (lp->xres) * (lp->yres) * (lp->bits_per_pixel));
    // 关闭屏幕
    close(lp->fd);
}

/*
    lcd_draw_point:能够在指定的屏幕的指定的位置显示一个指定的颜色
*/
void lcd_draw_point(lcd *lp, int x, int y, int colour) 
{
    if (lp == NULL) return ;

    if (x >= lp->xres || x < 0 || y >= lp->yres || y < 0) {
        printf("brother,point out of the lcd\n");
        return ;
    }
    *(lp->plcd + lp->xres * y + x) = colour;
}

/*
    lcd_clear:把屏幕刷成指定的颜色
*/
void lcd_clear(lcd *lp, int colour) 
{
    for (int y = 0; y < lp->yres; y++) 
    {
        for (int x = 0; x < lp->xres; x++)
        {
            lcd_draw_point(lp, x, y, colour);
        }
    }
}

/*
    在屏幕上指定的位置(x,y)显示一个指定大小,指定颜色的矩形
*/
void lcd_draw_rect(lcd *lp, int x, int y, int w, int h, int colour) 
{
    if (lp == NULL) return ;

    for (int i = x; i <= x + w; i++) {
        for (int j = y; j <= y + h; j++) {
            if (i >= 0 && i < lp->xres && j >= 0 && j < lp->yres)
            {
                lcd_draw_point(lp, i, j, colour);
            }
        }
    }
}

/*
    在屏幕上指定的位置(x,y)显示一个指定大小,指定颜色的圆
*/
void lcd_draw_cir(lcd *lp, int x, int y, int r, int colour) 
{
    if (lp == NULL) return ;

    for (int i = x - r; i <= x + r; i++)
    {
        for (int j = y - r; j <= y + r; j++)
        {
            if (i >= 0 && i < lp->xres && j >= 0 && j < lp->yres && 
                (i - x) * (i - x) + (j - y) * (j - y) <= r * r)
            {
                lcd_draw_point(lp, i, j, colour);
            }
        }
    }
}

5. 模块化思想：把大问题分解成小问题

1. 建立一个源代码工程

        src/                          源代码(.c   .h   .cpp   Makefile)

 

        libs/                         项目用到的第三方库(jpg解析)

 

        inc/                          第三方库的头文件

        readme.txt              项目介绍，功能，作者，编译方法，bugs......

        changelog.txt         修改日志

2. 确定程序的大致框架

        思路流程

嵌入式小聪
关注
  • 17
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式系统/ARM技术中的Linux frame buffer驱动设计与实现
10-23
严格来讲，Linux这个词本身只表示Linux内核，但在实际上人们已经习惯了用Linux来形容整个基于Linux内核，并且使用GNU 工程各种工具和数据库的操作系统。 　随着世界经济的迅速发展，液晶显示屏广泛应用于手机、PDA、...
afbc--arm frame buffer compression
06-01
arm的图像压缩格式简介，让你对帧压缩有个基本了解。
Framebuffer文章收集
weixin_33717298的博客
04-20 232
http://bbs.chinaunix.net/thread-1932291-1-1.html ...
【Linux】Framebuffer 应用
weixin_47596351的博客
02-17 1002
_u32 type;__u32 xres;__u32 yres;/*!__u32 sync;
LCD framebuffer
zhenwenxian的专栏
09-30 1831
一、FrameBuffer的原理    FrameBuffer 是出现在 2.2.xx 内核当中的一种驱动程序接口。    Linux是工作在保护模式下，所以用户态进程是无法象DOS那样使用显卡BIOS里提供的中断调用来实现直接写屏，Linux抽象出 FrameBuffer这个设备来供用户态进程实现直接写屏。Framebuffer机制模仿显卡的功能，将显卡硬件结构抽象掉，可以通过 Frameb
Linux Framebuffer 简介
我的博客
05-20 692
Linux Framebuffer 是一种用于在 Linux 系统中显示图形的设备驱动程序接口。它将帧缓冲区抽象为一个设备文件，应用程序可以通过读写该文件来实现对图像的显示和修改。
LINUX framebuffer
maopig的专栏
02-01 1703
http://wangshh03.blog.163.com/blog/static/49103415201001231317484/ 一、FrameBuffer的原理     FrameBuffer 是出现在 2.2.xx 内核当中的一种驱动程序接口。     Linux是工作在保护模式下，所以用户态进程是无法象DOS那样使用显卡BIOS里提供的中断调用来实现直接写屏，
linux frame buffer 学习资料
05-19
linux frame buffer 相关的资料。相关framebuffer 的学习还可以参考Linux 2.2 Framebuffer Device Programming Tutorial
基于SEP4O2O的Linux frame buffer驱动设计
10-19
随着世界经济的迅速发展，液晶显示屏广泛应用于手机、PDA、金融终端等电子产品上，而在嵌入式电子领域，Linux操作系统占有越来越大的市场份额。因而本文提出在嵌入式Linux平台上实现液晶显示器的功能，详细叙述了...
intel740 linux frame-buffer driver-开源
05-04
这是用于基于Intel740的视频板的帧缓冲设备驱动程序。
#Linux五、 Framebuffer应用编程
Pretender_1205的博客
07-19 96
在Linux系统中通过Framebuffer驱动程序来控制LCD。Frame是帧的意思，buffer是缓冲的意思，这意味着Framebuffer就是一块内存，里面保存着一帧图像。Framebuffer中保存着一帧图像的每一个像素颜色值，假设LCD的分辨率是1024x768，每一个像素的颜色用32位来表示，那么Framebuffer的大小就是：1024x768x32/8=3145728字节。① 驱动程序设置好LCD控制器：根据LCD的参数设置LCD控制器的时序、信号极性；
linux设置framebuffer的问题
egxsun的专栏
12-27 1602
在linux下开发minigui程序需要使用FramBuffer， 设置vga=0x0317(1024x768x64k),在实际使用中发现字符界面显示有问题，现只好使用qvfb,在www.minigui.com网站有qvfb下载，下载后解压缩，并./configure->make->su -c make install 安装，安装好后把qvfb拷贝到/usr/bin目录下就可以使用了。
Linux framebuffer简介及操作
欢迎光临
01-13 3889
Framebuffer简介 ：        帧缓冲（framebuffer）是Linux为显示设备提供的一个接口，把显存抽象后的一种设备，他允许上层应用程序在图形模式下直接对显示缓冲区进行读写操作。framebuffer是LCD对应的一中HAL（硬件抽象层），提供抽象的，统一的接口操作，用户不必关心硬件层是怎么实施的。这些都是由Framebuffer设备驱动来完成的。
linux图像显示（一）framebuffer操作
JT同学的博客
12-12 7975
linux图像显示 linux图像显示（一）framebuffer操作 linux图像显示（二）bmp图片 linux图像显示（三）使用libjpg处理jpg图片 linux图像显示（四）使用libpng处理png图片 linux图像显示（五）使用freetype处理矢量字体 下面给了一个linux下操作framebuffer的示例代码，如果要显示图片，只需要调用fb_draw_...
linux-journal日志文件特别大怎么办，journal日志文件学习
你是我的天晴
04-28 317
今天发现磁盘容量不多了，就去清理磁盘，发现这个文件特别大：journal，特此来学习下。
Linux 第十八章
一怀明月的博客
05-01 1270
程序地址空间 区间的地址分布 真正理解同一个地址进行读取不同内容 地址空间 虚拟地址和物理地址 虚拟地址： 物理地址： struct mm_struct 页表
【Linux】冯·诺依曼体系结构
最新发布
2201_76024104的博客
05-06 267
因为我们的操作系统就是一个软件，它可以用来管理内存，操作系统写的好不好，就决定了计算机的效率高不高。从你的键盘到内存再到CPU，CPU中要对信息进行一些处理，最简单的要加上发送的时间，人物等，然后在经过内存到网卡，通过网络到你朋友的网卡，再到内存到CPU，要对收到的信息进行分析，再到内存再到显示器上。了，因为我们的CPU可以做的非常快，而数据之间的拷贝是远不如CPU的处理速度快的。越靠上，离CPU越近，就是直接和CPU交换数据，效率越高，但是造价越高，容量越小。，让我们更多人使用，这也是内存的意义。
linux上can接收和发送帧代码
06-13
在Linux上使用SocketCAN可以很方便地进行CAN数据的接收和发送。以下是一个简单的例子： ``` #include #include #include #include #include #include #include #include <linux/can.h> #include <linux/can/...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值