【瑞芯微RV1126(板端摄像头图像数据采集)】②使用v4l2视频设备驱动框架采集图像数据

RV1126开发板：使用v4l2视频设备驱动框架采集图像数据

前言

本系列的目的是，不仅仅将能够进行图片推理的模型部署于板端，还提供了两种摄像头数据采集的方法，集成到自己的深度学习推理代码之后，可以根据应用场景的不同实现按键控制拍照推理或者是实时推理并显示。
本系列第一篇：https://blog.csdn.net/m0_71523511/article/details/139636367
本系列第二篇：本文
本系列第三篇：https://blog.csdn.net/m0_71523511/article/details/139011550

在本系列第三篇博客中，最后我有提到，读取摄像头数据来进行实时推理或者拍照推理，在那里提供了两种思路：①按照这系列的第一篇博客，搭建环境，调用opencv的高级函数采集图像数据；②按照这篇博客，学习使用v4l2视频设备驱动框架来采集图像数据，本文还提供了板端按键和lcd的示例代码，方便后续集成到自己的深度学习板端项目中。

参考资料：【正点原子】I.MX6U 嵌入式 Linux C 应用编程指南，https://pan.baidu.com/s/1inZtndgN-L3aVfoch2-sKA#list/path=%2F，提取码：m65i，里面有一个文档，名字是：【正点原子】I.MX6U嵌入式Linux C应用编程指南V1.1。
想搞懂v4l2代码的话，建议先看第一章、第二章、第四章、第十四章的存储映射IO，最后再看第二十六章，跟着26.2写代码就可以运行，如果还想使用按键和将图像显示到LCD屏幕上的话还需要看第十八章、二十章等。接下来将每个部分的代码先单独拿出来，头文件就先全部给出。

一、按键

简要介绍：Linux 系统为了统一管理输入设备，实现了一套能够兼容所有输入设备的框架，那么这个框架就
是 input 子系统。驱动开发人员基于 input 子系统开发输入设备的驱动程序， input 子系统可以屏蔽硬件的差
异，向应用层提供一套统一的接口。
基于 input 子系统注册成功的输入设备，都会在/dev/input 目录下生成对应的设备节点（设备文件），设备节点名称通常为 eventX（X 表示一个数字编号 0、 1、 2、 3 等），譬如/dev/input/event0等，通过读取这些设备节点可以获取输入设备上报的数据。
在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc_c.h>
#include <opencv2/core.hpp> 
#include <linux/input.h>
#include <linux/videodev2.h>
#include <errno.h>
#include <string.h>
#include <sys/mman.h>
#include <jpeglib.h>
#include <pthread.h>
#include <linux/fb.h>
#include <vector>
#include <iostream>
#include <fstream>
#include <stdint.h>
#include <algorithm>

//按键相关
int key_flag = 0;
int fd_key;

void key_input_Init(const char* key_path)
{
    /*  打开按键文件设备 */
    if (0 > (fd_key = open(key_path, O_RDONLY))) {
        perror("open key_devices error");
        exit(-1);
    }
}
 /*  按键线程 */
static void *key_ctr_takephoto(void *arg)
{
    struct input_event in_ev = {0};     /*  按键事件的返回值会存储到此结构体中，通过判断结构体成员来判断按键的状态 */
    while(1)
    {
         if (sizeof(struct input_event) !=
            read(fd_key, &in_ev, sizeof(struct input_event))) {
            perror("read error");
            exit(-1);
        }
        if (EV_KEY == in_ev.type)
        {
            switch (in_ev.value) {
                case 0:
                    printf("code<%d>: 松开\n", in_ev.code);
                    break;
                case 1:
                    printf("code<%d>: 按下\n", in_ev.code);
                    key_flag = 1;
                    break;
                case 2:
                    printf("code<%d>: 长按\n", in_ev.code);
                    break;
            }
        }
    }
}

int main(int argc,char **argv)
{
        //按键初始化
        key_input_Init(argv[2]);
        /**  按键线程创建  **/  
	    ret = pthread_create(&tid, NULL, key_ctr_takephoto, NULL);
	    if (ret) {
	        fprintf(stderr, "thread create failed: %s\n", strerror(ret));
	        exit(-1);
	    }
	    if(key_flag == 1)
	    {
	        /*  处理 */
	    }
}

二、LCD显示

简要介绍：
在 Linux 系统中，显示设备被称为 FrameBuffer 设备（帧缓冲设备），所以 LCD 显示屏自然而言就是 FrameBuffer 设备。FrameBuffer 设备对应的设备文件为/dev/fbX（X 为数字， 0、 1、 2、 3 等）， Linux
下可支持多个 FrameBuffer 设备，最多可达 32 个，分别为/dev/fb0 到/dev/fb31。
在这里插入图片描述
在应用程序中，操作/dev/fbX 的一般步骤如下：

①、首先打开/dev/fbX 设备文件。
②、 使用 ioctl()函数获取到当前显示设备的参数信息，譬如屏幕的分辨率大小、像素格式，根据屏幕参
数计算显示缓冲区的大小。
③、通过存储映射 I/O 方式将屏幕的显示缓冲区映射到用户空间（mmap）。
④、映射成功后就可以直接读写屏幕的显示缓冲区，进行绘图或图片显示等操作了。
⑤、完成显示后， 调用 munmap()取消映射、并调用 close()关闭设备文件。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc_c.h>
#include <opencv2/core.hpp> 
#include <linux/input.h>
#include <linux/videodev2.h>
#include <errno.h>
#include <string.h>
#include <sys/mman.h>
#include <pthread.h>
#include <linux/fb.h>
#include <vector>
#include <iostream>
#include <fstream>
#include <stdint.h>
#include <algorithm>

//Lcd相关
#define SHOW_X 300
#define SHOW_Y 300
uint32_t bits_per_pixel;    //像素深度
uint32_t xres_virtual;    //LCD X 分辨率
static int fd_lcd = -1;
static unsigned short *lcd_screen_base = NULL;    //映射后的显存基地址

/* lcd初始化  */
void Framebuffer_Lcd_Init(const char* framebuffer_device_path)
{
    struct fb_var_screeninfo screen_info;   //存储可变参数

    if ((fd_lcd = open(framebuffer_device_path, O_RDWR)) >= 0) {
        if (!ioctl(fd_lcd, FBIOGET_VSCREENINFO, &screen_info)) {
            xres_virtual = screen_info.xres_virtual;
            bits_per_pixel = screen_info.bits_per_pixel;
        }
    }
    else{
        std::cerr << "Failed to open framebuffer device." << std::endl;
        exit(-1);
    }
    /* 将显示缓冲区映射到进程地址空间 */
    size_t screen_size = xres_virtual * bits_per_pixel / 8;
    lcd_screen_base =static_cast<unsigned short*>(mmap(NULL, screen_size, PROT_WRITE | PROT_READ, MAP_SHARED, fd_lcd, 0));
    if ( (void *)lcd_screen_base == MAP_FAILED) {
        std::cerr << "Failed to map framebuffer device to memory." << std::endl;
        close(fd_lcd);
        exit(-1);
    }
}
void Framebuffer_Lcd_Cleanup()
{
    if (lcd_screen_base != NULL && lcd_screen_base != MAP_FAILED) {
        munmap(lcd_screen_base, xres_virtual * bits_per_pixel / 8);
    }
    if (fd_lcd >= 0) {
        close(fd_lcd);
    }
}
/* 显示图像，这里根据自己的需求进行更改 */
void Lcd_show_picture(const cv::Mat& image) {
    cv::Mat convert_image;
    cv::resize(image, convert_image, cv::Size(SHOW_X, SHOW_Y)); 
    cv::Size2f image_size = convert_image.size();
    cv::Mat framebuffer_image;

    cv::cvtColor(convert_image, framebuffer_image, cv::COLOR_BGR2BGR565);
     for (int y = 0; y < image_size.height; y++) {
         memcpy(lcd_screen_base + y * xres_virtual * 2, convert_image.ptr(y), image_size.width * 2);
    }
}

int main(int argc,char **argv)
{
    //Lcd初始化
    Framebuffer_Lcd_Init(argv[1]);
    if(...)
    {
        Lcd_show_picture(frame);
    }
}

三、V4L2 摄像头应用编程

简要介绍：V4L2 是 Video for linux two 的简称，是 Linux 内核中视频类设备的一套驱动框架，为视频类设备驱动
开发和应用层提供了一套统一的接口规范。使用 V4L2 设备驱动框架注册的设备会在 Linux 系统/dev/目录下生成对应的设备节点文件，设备节点的名称通常为 videoX（X 标准一个数字编号， 0、 1、 2、 3……），每一个 videoX 设备文件就代表一个视频类设备。应用程序通过对 videoX 设备文件进行 I/O 操作来配置、使用设备类设备：
在这里插入图片描述
V4L2 设备驱动框架编程模式：

1. 首先是打开摄像头设备；
2. 查询设备的属性或功能；
3. 设置设备的参数，譬如像素格式、 帧大小、 帧率；
4. 申请帧缓冲、 内存映射；
5. 帧缓冲入队；
6. 开启视频采集；
7. 帧缓冲出队、对采集的数据进行处理；
8. 处理完后，再次将帧缓冲入队，往复；
9. 结束采集

代码中注释非常清楚，配合开发文档看，很容易就能看懂。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc_c.h>
#include <opencv2/core.hpp> 
#include <linux/input.h>
#include <linux/videodev2.h>
#include <errno.h>
#include <string.h>
#include <sys/mman.h>
#include <pthread.h>
#include <linux/fb.h>
#include <vector>
#include <iostream>
#include <fstream>
#include <stdint.h>
#include <algorithm>

int main(int argc,char **argv)
{
    struct v4l2_capability v_cap;  //存储查询到的设备属性/能力/功能，在开发之前需要通过VIDIOC_QUERYCAP、VIDIOC_ENUM_FMT、VIDIOC_G_FMT指令，使用ioctl查询摄像头的信息，以便后续开发
    struct v4l2_fmtdesc fmtdesc;  //存储枚举出摄像头支持的所有像素格式
    struct v4l2_frmsizeenum frmsize;  //存储枚举出来的摄像头所支持的所有视频采集分辨率(ioctl(int fd, VIDIOC_ENUM_FRAMESIZES, struct v4l2_frmsizeenum *frmsize);)
    struct v4l2_format fmt;  //存储 查看或设置当前的帧格式
    struct v4l2_streamparm streamparm;  //设置或获取当前的流类型相关参数,没啥用
    struct v4l2_requestbuffers reqbuf;  //存储申请帧缓冲的信息
    struct v4l2_buffer buf;  //存储查询到的帧缓冲队列的信息
    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  //存储打开或关闭视频采集的信息
    
    void *frm_base[3];  //帧缓冲映射到用户空间的地址
    pthread_t tid;  //按键线程句柄
    int ret;
    int fd_cam = -1;
    
    //参数个数校验
    if (4 != argc) {
      fprintf(stderr, "usage: %s <output-lcd-dev>,%s <input-key-dev>,%s <input-camera-dev>", argv[1],argv[2],argv[3]);
      exit(-1);
    }
    
    //打开摄像头设备文件
    fd_cam = open(argv[3],O_RDWR);
    if(fd_cam < 0)
    {
        fprintf(stderr, "open error: %s: %s\n", argv[3], strerror(errno));
        exit(-1);
    }
    else
    {
        printf("open-camera-success\n");
    }

    /* 查询设备的属性/能力/功能 : VIDIOC_QUERYCAP */
    //ioctl(int fd, VIDIOC_QUERYCAP, struct v4l2_capability *cap); //通过 ioctl()将获取到一个 struct v4l2_capability 类型的数据
    //可以通过判断结构体中的 capabilities 字段是否包含 V4L2_CAP_VIDEO_CAPTURE、 来确定它是否是一个摄像头设备。下面三点是获取参数示例
            /* 1、判断摄像头是否可以cap图像 */
            //ioctl(fd, VIDIOC_QUERYCAP, &v_cap);
            //if (!(V4L2_CAP_VIDEO_CAPTURE & v_cap.capabilities)) {
                //fprintf(stderr, "Error: No capture video device!\n");
                //return -1;
            //}
            //else
            //{
                //printf("have capture video device!\n");
            //}
            /* 2、枚举出摄像头所支持的所有像素格式以及描述信息 : 支持yvuv和jpeg*/
            //fmtdesc.index = 0;
            //fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
            //while (0 == ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc)) {
                //printf("fmt: %s <0x%x>\n", fmtdesc.description, fmtdesc.pixelformat);
                //fmtdesc.index++;
            //}

            /* 3、枚举出摄像头所支持的frame_size：1280*720；800*600；640*480；......*/
            //frmsize.index = 0;
            //frmsize.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
            //frmsize.pixel_format = V4L2_PIX_FMT_YUYV;
            //while (0 == ioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frmsize)) {
                //printf("frame_size<%d*%d>\n", frmsize.discrete.width, frmsize.discrete.height);
                //frmsize.index++;
            //}
    
    /* 设置帧格式信息 : VIDIOC_S_FMT (要设置像素格式，首先得知道该设备支持哪些像素格式,ioctl(int fd, VIDIOC_ENUM_FMT, struct v4l2_fmtdesc *fmtdesc);)*/
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  //type 字 段 需 要 在 调 用 ioctl() 之 前 设 置 它 的 值
    if (0 > ioctl(fd_cam, VIDIOC_G_FMT, &fmt)) { //将获取到的帧格式信息存储到fmt结构体对象中
      perror("ioctl error");
      return -1;
    }
    printf("width:%d, height:%d format:%d\n", fmt.fmt.pix.width, fmt.fmt.pix.height, fmt.fmt.pix.pixelformat);
    fmt.fmt.pix.width = 1280;  //根据自己的需求设置帧格式信息
    fmt.fmt.pix.height = 720;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;  //设置成YUYV格式，因为我这个usb摄像头只支持这个格式
    if (0 > ioctl(fd_cam, VIDIOC_S_FMT, &fmt)) { 
      perror("ioctl error");
      return -1;
    }
        
    /**  申请帧缓冲队列 : VIDIOC_REQBUFS （读取摄像头数据的方式有两种，一种是 read 方式另一种则是 streaming 方式，使用streaming I/O 方式，我们需要向设备申请帧缓冲，并将帧缓冲映射到应用程序进程地址空间中，帧缓冲顾名思义就是用于存储一帧图像数据的缓冲区）**/   
    reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//type 字 段 需 要 在 调 用 ioctl() 之 前 设 置 它 的 值，表示是视频流采集
    reqbuf.count = 3; //申请帧缓冲的数量
    reqbuf.memory = V4L2_MEMORY_MMAP;//通常将 memory 设置为 V4L2_MEMORY_MMAP 即可
    if (0 > ioctl(fd_cam, VIDIOC_REQBUFS, &reqbuf)) {
        fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
        return -1;
    }//streaming I/O 方式会在内核空间中维护一个帧缓冲队列， 驱动程序会将从摄像头读取的一帧数据写入到队列中的一个帧缓冲，接着将下一帧数据写入到队列中的下一个帧缓冲；当应用程序需要读取一帧数据时，需要从队列中取出一个装满一帧数据的帧缓冲，这个取出过程就叫做出队；当应用程序处理完这一帧数据后，需要再把这个帧缓冲加入到内核的帧缓冲队列中，这个过程叫做入队！
    
    /**  将帧缓冲队列映射到进程地址空间：mmap,之后直接操作这块地址就可以实现视频数据的读取（上一步申请的帧缓冲， 该缓冲区实质上是由内核所维护的，应用程序不能直接读
取该缓冲区的数据，我们需要将其映射到用户空间中）  **/   
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for (buf.index = 0; buf.index < reqbuf.count; buf.index++) {
        ioctl(fd_cam, VIDIOC_QUERYBUF, &buf);  //查询帧缓冲:VIDIOC_QUERYBUF，信息存储到buf结构体中
        frm_base[buf.index] = mmap(NULL, buf.length,PROT_READ | PROT_WRITE, MAP_SHARED,fd_cam, buf.m.offset);
        if (MAP_FAILED == frm_base[buf.index]) {
            perror("mmap error");
            return -1;
            }
     }
     
    /**  帧缓冲入队操作 ： VIDIOC_QBUF （将三个帧缓冲放入内核的帧缓冲队列（入队操作）中） **/   
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for (buf.index = 0; buf.index < 3; buf.index++) {
        if (0 > ioctl(fd_cam, VIDIOC_QBUF, &buf)) {
            perror("ioctl error");
            return -1;
        }
    }
    /**  开启视频采集 ：VIDIOC_STREAMON （将三个帧缓冲放入到帧缓冲队列中之后，接着便可以打开摄像头、开启图像采集了）  **/  
    if (0 > ioctl(fd_cam, VIDIOC_STREAMON, &type)) {
        perror("ioctl error");
        return -1;
    }
    /**  读取数据、对数据进行处理  **/   
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    while(1){
        for(buf.index = 0; buf.index < 3; buf.index++) {
            ioctl(fd_cam, VIDIOC_DQBUF, &buf); //帧缓冲出队操作：VIDIOC_DQBUF（直接读取每一个帧缓冲的在用户空间的映射区即可读取到摄像头采集的每一帧图像数据。在读取数据之前，需要将帧缓冲从内核的帧缓冲队列中取出，这个操作叫做帧缓冲出队）
            if(....)
            {
                // 处理这一帧数据
                cv::Mat frame(fmt.fmt.pix.height, fmt.fmt.pix.width, CV_8UC2, frm_base[buf.index]); // 创建一个与帧数据相同尺寸的图像
                cv::Mat converted; // 用于转换格式的临时图像
                
                // 将YUYV格式的图像转换为BGR格式
                cv::cvtColor(frame, converted, cv::COLOR_YUV2BGR_YUYV);
                
                // 保存图像
                std::string filename = "frame.jpg";
                cv::imwrite(filename, converted);
                
                /* 这里可以添加深度学习模型推理的相关代码（建议是在已经能够读取图片并进行推理的代码中，移植进本代码）  */
                /*
                    情况1：
                        只想通过按键按下之后，推理一张图片并将结果显示在lcd屏幕上
                        例如：给出伪代码
                        ①读取保存的jpg图像
                        ②图像格式转换，送入模型推理
                        ③后处理
                        ④调用lcd显示函数，将经过后处理的结果图送入lcd进行显示
                        
                    情况2：
                        实时将推理结果显示到lcd屏幕上，那么就不需要这个key_flag判断，直接进行推理，将推理结果图片进行显示即可。需要修改图片格式，以适配lcd显示的输入图像要求。
                        （大部分开发板都是可以支持opencv的高级函数直接读取摄像头图像数据的，本代码适合正在学习嵌入式应用开发的小伙伴，学习应用层如何通过v4l2驱动框架来实现摄像头数据
                        采集。如果觉得没必要的话，若是板子支持opencv的capture调用，那就直接用，这里的按键和lcd还是有使用价值的；若是板子不直接支持opencv的capture调用，那就需要
                        在开发的虚拟机环境中，使用交叉编译工具链交叉编译完整的opencv，这样就能调用capture函数直接读取摄像头数据了，注：本代码是在rv1126的虚拟机环境中开发，交叉编译
                        之后生成的可执行文件再放到板端运行，可以参考博客中另一篇文章，关于交叉编译opencv的。）
                */
                
            }
            ioctl(fd_cam, VIDIOC_QBUF, &buf);  //一帧结束之后再次帧缓冲入队操作
        }
    }
    
    exit(-1);
}

四、完整代码

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc_c.h>
#include <opencv2/core.hpp> 
#include <linux/input.h>
#include <linux/videodev2.h>
#include <errno.h>
#include <string.h>
#include <sys/mman.h>
#include <pthread.h>
#include <linux/fb.h>
#include <vector>
#include <iostream>
#include <fstream>
#include <stdint.h>
#include <algorithm>

//按键相关
int key_flag = 0;
int fd_key;
//Lcd相关
#define SHOW_X 300
#define SHOW_Y 300
uint32_t bits_per_pixel;
uint32_t xres_virtual;
static int fd_lcd = -1;
static unsigned short *lcd_screen_base = NULL;

void Framebuffer_Lcd_Init(const char* framebuffer_device_path)
{
    struct fb_var_screeninfo screen_info;

    if ((fd_lcd = open(framebuffer_device_path, O_RDWR)) >= 0) {
        if (!ioctl(fd_lcd, FBIOGET_VSCREENINFO, &screen_info)) {
            xres_virtual = screen_info.xres_virtual;
            bits_per_pixel = screen_info.bits_per_pixel;
        }
    }
    else{
        std::cerr << "Failed to open framebuffer device." << std::endl;
        exit(-1);
    }

    size_t screen_size = xres_virtual * bits_per_pixel / 8;
    lcd_screen_base =static_cast<unsigned short*>(mmap(NULL, screen_size, PROT_WRITE | PROT_READ, MAP_SHARED, fd_lcd, 0));
    if ( (void *)lcd_screen_base == MAP_FAILED) {
        std::cerr << "Failed to map framebuffer device to memory." << std::endl;
        close(fd_lcd);
        exit(-1);
    }
}
void Framebuffer_Lcd_Cleanup()
{
    if (lcd_screen_base != NULL && lcd_screen_base != MAP_FAILED) {
        munmap(lcd_screen_base, xres_virtual * bits_per_pixel / 8);
    }
    if (fd_lcd >= 0) {
        close(fd_lcd);
    }
}
void Lcd_show_picture(const cv::Mat& image) {
    cv::Mat transposed_image;
    cv::resize(image, transposed_image, cv::Size(SHOW_X, SHOW_Y)); 
    cv::Size2f image_size = transposed_image.size();
    cv::Mat framebuffer_compat;

    switch (bits_per_pixel) {
        case 16:
            cv::cvtColor(transposed_image, framebuffer_compat, cv::COLOR_BGR2BGR565);
            for (int y = 0; y < image_size.height; y++) {
                memcpy(lcd_screen_base + y * xres_virtual * 2, framebuffer_compat.ptr(y), image_size.width * 2);
            }
            break;
        case 32: {
            std::vector<cv::Mat> split_bgr;
            cv::split(transposed_image, split_bgr);
            split_bgr.push_back(cv::Mat(image_size, CV_8UC1, cv::Scalar(255)));
            cv::merge(split_bgr, framebuffer_compat);
            for (int y = 0; y < image_size.height; y++) {
                memcpy(lcd_screen_base + y * xres_virtual * 4, framebuffer_compat.ptr(y), image_size.width * 4);
            }
        } break;
        default:
            std::cerr << "Unsupported depth of framebuffer." << std::endl;
            break;
    }   
}

void key_input_Init(const char* key_path)
{
    if (0 > (fd_key = open(key_path, O_RDONLY))) {
        perror("open key_devices error");
        exit(-1);
    }
}

static void *key_ctr_takephoto(void *arg)
{
    struct input_event in_ev = {0};
    while(1)
    {
         if (sizeof(struct input_event) !=
            read(fd_key, &in_ev, sizeof(struct input_event))) {
            perror("read error");
            exit(-1);
        }
        if (EV_KEY == in_ev.type)
        {
            switch (in_ev.value) {
                case 0:
                    printf("code<%d>: 松开\n", in_ev.code);
                    break;
                case 1:
                    printf("code<%d>: 按下\n", in_ev.code);
                    key_flag = 1;
                    break;
                case 2:
                    printf("code<%d>: 长按\n", in_ev.code);
                    break;
            }
        }
    }
}

int main(int argc,char **argv)
{
    struct v4l2_capability v_cap;  //存储查询到的设备属性/能力/功能，在开发之前需要通过VIDIOC_QUERYCAP、VIDIOC_ENUM_FMT、VIDIOC_G_FMT指令，使用ioctl查询摄像头的信息，以便后续开发
    struct v4l2_fmtdesc fmtdesc;  //存储枚举出摄像头支持的所有像素格式
    struct v4l2_frmsizeenum frmsize;  //存储枚举出来的摄像头所支持的所有视频采集分辨率(ioctl(int fd, VIDIOC_ENUM_FRAMESIZES, struct v4l2_frmsizeenum *frmsize);)
    struct v4l2_format fmt;  //存储 查看或设置当前的帧格式
    struct v4l2_streamparm streamparm;  //设置或获取当前的流类型相关参数,没啥用
    struct v4l2_requestbuffers reqbuf;  //存储申请帧缓冲的信息
    struct v4l2_buffer buf;  //存储查询到的帧缓冲队列的信息
    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  //存储打开或关闭视频采集的信息
    
    void *frm_base[3];  //帧缓冲映射到用户空间的地址
    pthread_t tid;  //按键线程句柄
    int ret;
    int fd_cam = -1;
    
    //参数个数校验
    if (4 != argc) {
      fprintf(stderr, "usage: %s <output-lcd-dev>,%s <input-key-dev>,%s <input-camera-dev>", argv[1],argv[2],argv[3]);
      exit(-1);
    }
    
    //Lcd初始化
    Framebuffer_Lcd_Init(argv[1]);
    //按键初始化
    key_input_Init(argv[2]);
    
    //打开摄像头设备文件
    fd_cam = open(argv[3],O_RDWR);
    if(fd_cam < 0)
    {
        fprintf(stderr, "open error: %s: %s\n", argv[3], strerror(errno));
        exit(-1);
    }
    else
    {
        printf("open-camera-success\n");
    }

    /* 查询设备的属性/能力/功能 : VIDIOC_QUERYCAP */
    //ioctl(int fd, VIDIOC_QUERYCAP, struct v4l2_capability *cap); //通过 ioctl()将获取到一个 struct v4l2_capability 类型的数据
    //可以通过判断结构体中的 capabilities 字段是否包含 V4L2_CAP_VIDEO_CAPTURE、 来确定它是否是一个摄像头设备。下面三点是获取参数示例
            /* 1、判断摄像头是否可以cap图像 */
            //ioctl(fd, VIDIOC_QUERYCAP, &v_cap);
            //if (!(V4L2_CAP_VIDEO_CAPTURE & v_cap.capabilities)) {
                //fprintf(stderr, "Error: No capture video device!\n");
                //return -1;
            //}
            //else
            //{
                //printf("have capture video device!\n");
            //}
            /* 2、枚举出摄像头所支持的所有像素格式以及描述信息 : 支持yvuv和jpeg*/
            //fmtdesc.index = 0;
            //fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
            //while (0 == ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc)) {
                //printf("fmt: %s <0x%x>\n", fmtdesc.description, fmtdesc.pixelformat);
                //fmtdesc.index++;
            //}

            /* 3、枚举出摄像头所支持的frame_size：1280*720；800*600；640*480；......*/
            //frmsize.index = 0;
            //frmsize.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
            //frmsize.pixel_format = V4L2_PIX_FMT_YUYV;
            //while (0 == ioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frmsize)) {
                //printf("frame_size<%d*%d>\n", frmsize.discrete.width, frmsize.discrete.height);
                //frmsize.index++;
            //}
    
    /* 设置帧格式信息 : VIDIOC_S_FMT (要设置像素格式，首先得知道该设备支持哪些像素格式,ioctl(int fd, VIDIOC_ENUM_FMT, struct v4l2_fmtdesc *fmtdesc);)*/
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  //type 字 段 需 要 在 调 用 ioctl() 之 前 设 置 它 的 值
    if (0 > ioctl(fd_cam, VIDIOC_G_FMT, &fmt)) { //将获取到的帧格式信息存储到fmt结构体对象中
      perror("ioctl error");
      return -1;
    }
    printf("width:%d, height:%d format:%d\n", fmt.fmt.pix.width, fmt.fmt.pix.height, fmt.fmt.pix.pixelformat);
    fmt.fmt.pix.width = 1280;  //根据自己的需求设置帧格式信息
    fmt.fmt.pix.height = 720;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;  //设置成YUYV格式，因为我这个usb摄像头只支持这个格式
    if (0 > ioctl(fd_cam, VIDIOC_S_FMT, &fmt)) { 
      perror("ioctl error");
      return -1;
    }
        
    /**  申请帧缓冲队列 : VIDIOC_REQBUFS （读取摄像头数据的方式有两种，一种是 read 方式另一种则是 streaming 方式，使用streaming I/O 方式，我们需要向设备申请帧缓冲，并将帧缓冲映射到应用程序进程地址空间中，帧缓冲顾名思义就是用于存储一帧图像数据的缓冲区）**/   
    reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//type 字 段 需 要 在 调 用 ioctl() 之 前 设 置 它 的 值，表示是视频流采集
    reqbuf.count = 3; //申请帧缓冲的数量
    reqbuf.memory = V4L2_MEMORY_MMAP;//通常将 memory 设置为 V4L2_MEMORY_MMAP 即可
    if (0 > ioctl(fd_cam, VIDIOC_REQBUFS, &reqbuf)) {
        fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
        return -1;
    }//streaming I/O 方式会在内核空间中维护一个帧缓冲队列， 驱动程序会将从摄像头读取的一帧数据写入到队列中的一个帧缓冲，接着将下一帧数据写入到队列中的下一个帧缓冲；当应用程序需要读取一帧数据时，需要从队列中取出一个装满一帧数据的帧缓冲，这个取出过程就叫做出队；当应用程序处理完这一帧数据后，需要再把这个帧缓冲加入到内核的帧缓冲队列中，这个过程叫做入队！
    
    /**  将帧缓冲队列映射到进程地址空间：mmap,之后直接操作这块地址就可以实现视频数据的读取（上一步申请的帧缓冲， 该缓冲区实质上是由内核所维护的，应用程序不能直接读
取该缓冲区的数据，我们需要将其映射到用户空间中）  **/   
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for (buf.index = 0; buf.index < reqbuf.count; buf.index++) {
        ioctl(fd_cam, VIDIOC_QUERYBUF, &buf);  //查询帧缓冲:VIDIOC_QUERYBUF，信息存储到buf结构体中
        frm_base[buf.index] = mmap(NULL, buf.length,PROT_READ | PROT_WRITE, MAP_SHARED,fd_cam, buf.m.offset);
        if (MAP_FAILED == frm_base[buf.index]) {
            perror("mmap error");
            return -1;
            }
     }
     
    /**  帧缓冲入队操作 ： VIDIOC_QBUF （将三个帧缓冲放入内核的帧缓冲队列（入队操作）中） **/   
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for (buf.index = 0; buf.index < 3; buf.index++) {
        if (0 > ioctl(fd_cam, VIDIOC_QBUF, &buf)) {
            perror("ioctl error");
            return -1;
        }
    }
    /**  开启视频采集 ：VIDIOC_STREAMON （将三个帧缓冲放入到帧缓冲队列中之后，接着便可以打开摄像头、开启图像采集了）  **/  
    if (0 > ioctl(fd_cam, VIDIOC_STREAMON, &type)) {
        perror("ioctl error");
        return -1;
    }
    
    /**  按键线程创建  **/  
    ret = pthread_create(&tid, NULL, key_ctr_takephoto, NULL);
    if (ret) {
        fprintf(stderr, "thread create failed: %s\n", strerror(ret));
        exit(-1);
    }
    
    /**  读取数据、对数据进行处理  **/   
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    while(1){
        for(buf.index = 0; buf.index < 3; buf.index++) {
            ioctl(fd_cam, VIDIOC_DQBUF, &buf); //帧缓冲出队操作：VIDIOC_DQBUF（直接读取每一个帧缓冲的在用户空间的映射区即可读取到摄像头采集的每一帧图像数据。在读取数据之前，需要将帧缓冲从内核的帧缓冲队列中取出，这个操作叫做帧缓冲出队）
            if(key_flag == 1)
            {
                // 处理这一帧数据
                cv::Mat frame(fmt.fmt.pix.height, fmt.fmt.pix.width, CV_8UC2, frm_base[buf.index]); // 创建一个与帧数据相同尺寸的图像
                cv::Mat converted; // 用于转换格式的临时图像
                
                // 将YUYV格式的图像转换为BGR格式
                cv::cvtColor(frame, converted, cv::COLOR_YUV2BGR_YUYV);
                
                // 保存图像
                std::string filename = "frame.jpg";
                cv::imwrite(filename, converted);
                
                /* 这里可以添加深度学习模型推理的相关代码（建议是在已经能够读取图片并进行推理的代码中，移植进本代码）  */
                /*
                    情况1：
                        只想通过按键按下之后，推理一张图片并将结果显示在lcd屏幕上
                        例如：给出伪代码
                        ①读取保存的jpg图像
                        ②图像格式转换，送入模型推理
                        ③后处理
                        ④调用lcd显示函数，将经过后处理的结果图送入lcd进行显示
                        
                    情况2：
                        实时将推理结果显示到lcd屏幕上，那么就不需要这个key_flag判断，直接进行推理，将推理结果图片进行显示即可。需要修改图片格式，以适配lcd显示的输入图像要求。
                        （大部分开发板都是可以支持opencv的高级函数直接读取摄像头图像数据的，本代码适合正在学习嵌入式应用开发的小伙伴，学习应用层如何通过v4l2驱动框架来实现摄像头数据
                        采集。如果觉得没必要的话，若是板子支持opencv的capture调用，那就直接用，这里的按键和lcd还是有使用价值的；若是板子不直接支持opencv的capture调用，那就需要
                        在开发的虚拟机环境中，使用交叉编译工具链交叉编译完整的opencv，这样就能调用capture函数直接读取摄像头数据了，注：本代码是在rv1126的虚拟机环境中开发，交叉编译
                        之后生成的可执行文件再放到板端运行，可以参考博客中另一篇文章，关于交叉编译opencv的。）
                */
                
                key_flag = 0;
            }
            ioctl(fd_cam, VIDIOC_QBUF, &buf);  //一帧结束之后再次帧缓冲入队操作
        }
    }
    
    exit(-1);
}

将这里面自己需要用到的移植到自己的程序中即可，这里没用到.h文件，只需要写一个cmakelist即可编译运行。
cmakelists如下：

cmake_minimum_required(VERSION 3.10)

project(01)

# 设置C++标准
set(CMAKE_CXX_STANDARD 11)

# 寻找OpenCV包
find_package(OpenCV 4.2.0 REQUIRED)

# 添加可执行文件
add_executable(test test.cpp)

# 添加依赖库
find_package(Threads REQUIRED)  

# 链接依赖库
target_link_libraries(test
    Threads::Threads  # 多线程
    ${OpenCV_LIBS}
)

代码目录结构如下：
在这里插入图片描述

cd build
cmake ..
make
./test /dev/fb0 /dev/input/event1 /dev/video8
这里的设备文件需要根据自己的进行更换

接下来是c++面向对象的代码，旨在练习：
main.cpp

#include "v4l2_cam.h"

//鎸夐敭鐩稿叧
int key_flag = 0;


static void *key_ctr_takephoto(void *arg)
{
    unsigned char key;
    while(1)
    {
            key = getchar();
            if (key == '\n') { 
                key_flag = 1;
            }
    }
}

int main(int argc,char **argv)
{
    int ret;
    pthread_t tid;
    
    v4l2_camera v1;

    if (2 != argc) {
      fprintf(stderr, "usage:%s <input-camera-dev>", argv[1]);
      exit(-1);
    }

    ret = pthread_create(&tid, NULL, key_ctr_takephoto, NULL);
    if (ret) {
        fprintf(stderr, "thread create failed: %s\n", strerror(ret));
        exit(-1);
    }
    
    v1.camera_init(argv[1]);
    while(1){
            if(key_flag == 1)
            {
                v1.Start_video_captureandprocess();
                key_flag = 0;
            }
    }

    exit(-1);
}

v4l2_cam.cpp:

#include "v4l2_cam.h"

v4l2_camera::v4l2_camera()
{
    
}

void v4l2_camera::camera_init(char* arg)
{
    struct v4l2_capability v_cap;  //瀛樺偍鏌ヨ鍒扮殑璁惧灞炴€?鑳藉姏/鍔熻兘锛屽湪寮€鍙戜箣鍓嶉渶瑕侀€氳繃VIDIOC_QUERYCAP銆乂IDIOC_ENUM_FMT銆乂IDIOC_G_FMT鎸囦护锛屼娇鐢╥octl鏌ヨ鎽勫儚澶寸殑淇℃伅锛屼互渚垮悗缁紑鍙?
    struct v4l2_fmtdesc fmtdesc;  //瀛樺偍鏋氫妇鍑烘憚鍍忓ご鏀寔鐨勬墍鏈夊儚绱犳牸寮?
    struct v4l2_frmsizeenum frmsize;  //瀛樺偍鏋氫妇鍑烘潵鐨勬憚鍍忓ご鎵€鏀寔鐨勬墍鏈夎棰戦噰闆嗗垎杈ㄧ巼(ioctl(int fd, VIDIOC_ENUM_FRAMESIZES, struct v4l2_frmsizeenum *frmsize);)
    struct v4l2_streamparm streamparm;  //璁剧疆鎴栬幏鍙栧綋鍓嶇殑娴佺被鍨嬬浉鍏冲弬鏁?娌″暐鐢?
    struct v4l2_requestbuffers reqbuf;  //瀛樺偍鐢宠甯х紦鍐茬殑淇℃伅
    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  //瀛樺偍鎵撳紑鎴栧叧闂棰戦噰闆嗙殑淇℃伅

    //鎵撳紑鎽勫儚澶磋澶囨枃浠?
    v4l2_camera::fd_cam = open(arg,O_RDWR);
    if(v4l2_camera::fd_cam < 0)
    {
        fprintf(stderr, "open error: %s: %s\n", arg, strerror(errno));
        exit(-1);
    }
    else
    {
        printf("open-camera-success\n");
    }

    /* 璁剧疆甯ф牸寮忎俊鎭?: VIDIOC_S_FMT  */
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    if (0 > ioctl(v4l2_camera::fd_cam, VIDIOC_G_FMT, &fmt)) { 
      perror("ioctl error");
      exit(-1);
    }
    printf("width:%d, height:%d format:%d\n", fmt.fmt.pix.width, fmt.fmt.pix.height, fmt.fmt.pix.pixelformat);
    fmt.fmt.pix.width = 1280;  //鏍规嵁鑷繁鐨勯渶姹傝缃抚鏍煎紡淇℃伅
    fmt.fmt.pix.height = 720;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;  //璁剧疆鎴怸UYV鏍煎紡锛屽洜涓烘垜杩欎釜usb鎽勫儚澶村彧鏀寔杩欎釜鏍煎紡
    if (0 > ioctl(v4l2_camera::fd_cam, VIDIOC_S_FMT, &fmt)) { 
      perror("ioctl error");
      exit(-1);
    }

    /**  鐢宠甯х紦鍐查槦鍒?: VIDIOC_REQBUFS **/   
    reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//type 瀛?娈?闇€ 瑕?鍦?璋?鐢?ioctl() 涔?鍓?璁?缃?瀹?鐨?鍊硷紝琛ㄧず鏄棰戞祦閲囬泦
    reqbuf.count = 3; //鐢宠甯х紦鍐茬殑鏁伴噺
    reqbuf.memory = V4L2_MEMORY_MMAP;//閫氬父灏?memory 璁剧疆涓?V4L2_MEMORY_MMAP 鍗冲彲
    if (0 > ioctl(v4l2_camera::fd_cam, VIDIOC_REQBUFS, &reqbuf)) {
        fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
        exit(-1);
    }

    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for (buf.index = 0; buf.index < reqbuf.count; buf.index++) {
        ioctl(v4l2_camera::fd_cam, VIDIOC_QUERYBUF, &buf);  //鏌ヨ甯х紦鍐?VIDIOC_QUERYBUF锛屼俊鎭瓨鍌ㄥ埌buf缁撴瀯浣撲腑
        frm_base[buf.index] = mmap(NULL, buf.length,PROT_READ | PROT_WRITE, MAP_SHARED,v4l2_camera::fd_cam, buf.m.offset);
        if (MAP_FAILED == v4l2_camera::frm_base[buf.index]) {
            perror("mmap error");
            exit(-1);
            }
     }

    /**  甯х紦鍐插叆闃熸搷浣?锛?VIDIOC_QBUF 锛堝皢涓変釜甯х紦鍐叉斁鍏ュ唴鏍哥殑甯х紦鍐查槦鍒楋紙鍏ラ槦鎿嶄綔锛変腑锛?**/   
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for (buf.index = 0; buf.index < 3; buf.index++) {
        if (0 > ioctl(v4l2_camera::fd_cam, VIDIOC_QBUF, &buf)) {
            perror("ioctl error");
            exit(-1);
        }
    }
    
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    if (0 > ioctl(v4l2_camera::fd_cam, VIDIOC_STREAMON, &type)) {
        perror("ioctl error");
        exit(-1);
    }
}

void v4l2_camera::Start_video_captureandprocess()
{
        for(buf.index = 0; buf.index < 1; buf.index++) 
        {
             ioctl(fd_cam, VIDIOC_DQBUF, &buf); //帧缓冲出队操作：VIDIOC_DQBUF（直接读取每一个帧缓冲的在用户空间的映射区即可读取到摄像头采集的每一帧图像数据。在读取数据之前，需要将帧缓冲从内核的帧缓冲队列中取出，这个操作叫做帧缓冲出队）
                // 处理这一帧数据
                cv::Mat frame(fmt.fmt.pix.height, fmt.fmt.pix.width, CV_8UC2, frm_base[buf.index]); // 创建一个与帧数据相同尺寸的图像
                cv::Mat converted; // 用于转换格式的临时图像
                
                // 将YUYV格式的图像转换为BGR格式
                cv::cvtColor(frame, converted, cv::COLOR_YUV2BGR_YUYV);
                
                // 保存图像
                std::string filename = "frame.jpg";
                cv::imwrite(filename, converted);
                std::cout << "picture save success" << std::endl;
                
            ioctl(fd_cam, VIDIOC_QBUF, &buf);  //一帧结束之后再次帧缓冲入队操作
        }
}

v4l2_cam.h:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc_c.h>
#include <opencv2/core.hpp> 
#include <linux/input.h>
#include <linux/videodev2.h>
#include <errno.h>
#include <string.h>
#include <sys/mman.h>
#include <jpeglib.h>
#include <pthread.h>
#include <linux/fb.h>
#include <vector>
#include <iostream>
#include <fstream>
#include <stdint.h>
#include <algorithm>

class v4l2_camera
{
public:
    v4l2_camera();

    int fd_cam = -1;
    void *frm_base[3];  //甯х紦鍐叉槧灏勫埌鐢ㄦ埛绌洪棿鐨勫湴鍧€
    
    struct v4l2_buffer buf; 
    struct v4l2_format fmt;

    void camera_init(char *argv);
    void Start_video_captureandprocess();
};