LittleBear-原子源码驱动ov5640

摄像头

  • 一、驱动模块
    • 1、准备工具
    • 2、设备树配置
    • 3、源码拷贝
    • 4、配置文件
    • 5、编译生成驱动模块
  • 二、板子应用程序
  • 三、上机实验

一、驱动模块

由于原子的出厂源码提供全面的驱动源码,而教程源码只有部分字符设备驱动,本着学习的态度,一开始ipslcd屏幕和无线wifi都是在教程源码上开发的,本文将把源码中的ov5640驱动复制到教程源码中,整体不需做太多修改。

1、准备工具

  • 开发板教程对应的linux源码
  • 正点原子Linux出厂源码

2、设备树配置

/* iomxc复用 注意这里使用的引脚,其他设备就不能使用了,找到并注释掉*/
//pinctrl_csi1 pinctrl子系统
pinctrl_csi1: csi1grp {
	fsl,pins = <
		MX6UL_PAD_CSI_MCLK__CSI_MCLK		0x1b088
		MX6UL_PAD_CSI_PIXCLK__CSI_PIXCLK	0x1b088
		MX6UL_PAD_CSI_VSYNC__CSI_VSYNC		0x1b088
		MX6UL_PAD_CSI_HSYNC__CSI_HSYNC		0x1b088
		MX6UL_PAD_CSI_DATA00__CSI_DATA02	0x1b088
		MX6UL_PAD_CSI_DATA01__CSI_DATA03	0x1b088
		MX6UL_PAD_CSI_DATA02__CSI_DATA04	0x1b088
		MX6UL_PAD_CSI_DATA03__CSI_DATA05	0x1b088
		MX6UL_PAD_CSI_DATA04__CSI_DATA06	0x1b088
		MX6UL_PAD_CSI_DATA05__CSI_DATA07	0x1b088
		MX6UL_PAD_CSI_DATA06__CSI_DATA08	0x1b088
		MX6UL_PAD_CSI_DATA07__CSI_DATA09	0x1b088
	>;
};
//csi_pwn_rst pinctrl子系统
csi_pwn_rst: csi_pwn_rstgrp {
	fsl,pins = <
		MX6UL_PAD_GPIO1_IO02__GPIO1_IO02	0x10b0
		MX6UL_PAD_GPIO1_IO04__GPIO1_IO04	0x10b0
	>;
};

/* ov5640设备树 */
ov5640: ov5640@3c {
	compatible = "ovti,ov5640";
	reg = <0x3c>;
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_csi1
		     &csi_pwn_rst>;
	clocks = <&clks IMX6UL_CLK_CSI>;
	clock-names = "csi_mclk";
	pwn-gpios = <&gpio1 4 1>;
	rst-gpios = <&gpio1 2 0>;
	csi_id = <0>;
	mclk = <24000000>;
	mclk_source = <0>;
	status = "okay";
	port {
		ov5640_ep: endpoint {
			remote-endpoint = <&csi1_ep>;
		};
	};
};

3、源码拷贝

出厂源码路径:linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek/drivers/media/platform/mxc,复制当前文件夹到自己开发版本的对应路径下。
在这里插入图片描述

4、配置文件

配置文件路径:linux-imx-4.1.15-2.1.0-gc353ffb-v2.0/arch/arm/configs/imx_alientek_emmc_defconfig,linux内核编译是依赖于根目录下的.config文件,其实两个配置文件都是一个意思使用make xxx_defconfig图形界面保存可转变为本目录形式。
配置路径

Location:                                                             │  
  │     -> Device Drivers                                                   │  
  │       -> Multimedia support (MEDIA_SUPPORT [=y])                        │  
  │         -> V4L platform devices (V4L_PLATFORM_DRIVERS [=y]) 

具体配置不用改,出厂源码配置已经设置好了。

这里遇到的问题,虽然摄像头可以驱动了,但出厂配置文件太全面,在屏幕开发阶段,想使用ipslcd而关闭原配4.3寸LCD,在关掉原配LCD的配置时:

  • 配置路径
Location:                                                             │  
  │     -> Device Drivers                                                   │  
  │       -> Graphics support                                               │  
  │         -> Frame buffer Devices
  • 具体设置:尤其注意箭头位置
    LittleBear-原子源码驱动ov5640_第1张图片

5、编译生成驱动模块

在mxc/subdev下找到两个驱动模块,放到板子/lib/modules/4.1.15xxx/路径下(其他路径也可)。

  • ov5640_camera:用于摄像头的驱动。
  • mx6s_capture:用于板子捕获相关驱动。
    在这里插入图片描述

二、板子应用程序

秉承“先吃苦后享乐”的原则,驱动配置好了,接下来就是上层应用程序的调试,只需操作ov5640提供的video1设备接口和ipslcd提供的fb0设备接口,复制原子应用开发教程中的源码。

/***************************************************************
 Copyright © ALIENTEK Co., Ltd. 1998-2021. All rights reserved.
 文件名 : v4l2_camera.c
 作者 : 邓涛
 版本 : V1.0
 描述 : V4L2摄像头应用编程实战
 其他 : 无
 论坛 : www.openedv.com
 日志 : 初版 V1.0 2021/7/09 邓涛创建
 ***************************************************************/

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define FB_DEV              "/dev/fb0"      //LCD设备节点
#define FRAMEBUFFER_COUNT   3               //帧缓冲数量

/*** 摄像头像素格式及其描述信息 ***/
typedef struct camera_format {
    unsigned char description[32];  //字符串描述信息
    unsigned int pixelformat;       //像素格式
} cam_fmt;

/*** 描述一个帧缓冲的信息 ***/
typedef struct cam_buf_info {
    unsigned short *start;      //帧缓冲起始地址
    unsigned long length;       //帧缓冲长度
} cam_buf_info;

static int width;                       //LCD宽度
static int height;                      //LCD高度
static unsigned short *screen_base = NULL;//LCD显存基地址
static int fb_fd = -1;                  //LCD设备文件描述符
static int v4l2_fd = -1;                //摄像头设备文件描述符
static cam_buf_info buf_infos[FRAMEBUFFER_COUNT];
static cam_fmt cam_fmts[10];
static int frm_width, frm_height;   //视频帧宽度和高度

static int fb_dev_init(void)
{
    struct fb_var_screeninfo fb_var = {0};
    struct fb_fix_screeninfo fb_fix = {0};
    unsigned long screen_size;

    /* 打开framebuffer设备 */
    fb_fd = open(FB_DEV, O_RDWR);
    if (0 > fb_fd) {
        fprintf(stderr, "open error: %s: %s\n", FB_DEV, strerror(errno));
        return -1;
    }

    /* 获取framebuffer设备信息 */
    ioctl(fb_fd, FBIOGET_VSCREENINFO, &fb_var);
    ioctl(fb_fd, FBIOGET_FSCREENINFO, &fb_fix);

    screen_size = fb_fix.line_length * fb_var.yres;
    width = fb_var.xres;
    height = fb_var.yres;

    /* 内存映射 */
    screen_base = mmap(NULL, screen_size, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
    if (MAP_FAILED == (void *)screen_base) {
        perror("mmap error");
        close(fb_fd);
        return -1;
    }

    /* LCD背景刷白 */
    memset(screen_base, 0xFF, screen_size);
    return 0;
}

static int v4l2_dev_init(const char *device)
{
    struct v4l2_capability cap = {0};

    /* 打开摄像头 */
    v4l2_fd = open(device, O_RDWR);
    if (0 > v4l2_fd) {
        fprintf(stderr, "open error: %s: %s\n", device, strerror(errno));
        return -1;
    }

    /* 查询设备功能 */
    ioctl(v4l2_fd, VIDIOC_QUERYCAP, &cap);

    /* 判断是否是视频采集设备 */
    if (!(V4L2_CAP_VIDEO_CAPTURE & cap.capabilities)) {
        fprintf(stderr, "Error: %s: No capture video device!\n", device);
        close(v4l2_fd);
        return -1;
    }

    return 0;
}

static void v4l2_enum_formats(void)
{
    struct v4l2_fmtdesc fmtdesc = {0};

    /* 枚举摄像头所支持的所有像素格式以及描述信息 */
    fmtdesc.index = 0;
    fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FMT, &fmtdesc)) {

        // 将枚举出来的格式以及描述信息存放在数组中
        cam_fmts[fmtdesc.index].pixelformat = fmtdesc.pixelformat;
        strcpy(cam_fmts[fmtdesc.index].description, fmtdesc.description);
        fmtdesc.index++;
    }
}

static void v4l2_print_formats(void)
{
    struct v4l2_frmsizeenum frmsize = {0};
    struct v4l2_frmivalenum frmival = {0};
    int i;

    frmsize.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    frmival.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    for (i = 0; cam_fmts[i].pixelformat; i++) {

        printf("format<0x%x>, description<%s>\n", cam_fmts[i].pixelformat,
                    cam_fmts[i].description);

        /* 枚举出摄像头所支持的所有视频采集分辨率 */
        frmsize.index = 0;
        frmsize.pixel_format = cam_fmts[i].pixelformat;
        frmival.pixel_format = cam_fmts[i].pixelformat;
        while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FRAMESIZES, &frmsize)) {

            printf("size<%d*%d> ",
                    frmsize.discrete.width,
                    frmsize.discrete.height);
            frmsize.index++;

            /* 获取摄像头视频采集帧率 */
            frmival.index = 0;
            frmival.width = frmsize.discrete.width;
            frmival.height = frmsize.discrete.height;
            while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival)) {

                printf("<%dfps>", frmival.discrete.denominator /
                        frmival.discrete.numerator);
                frmival.index++;
            }
            printf("\n");
        }
        printf("\n");
    }
}

static int v4l2_set_format(void)
{
    struct v4l2_format fmt = {0};
    struct v4l2_streamparm streamparm = {0};

    /* 设置帧格式 */
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//type类型
    fmt.fmt.pix.width = width;  //视频帧宽度
    fmt.fmt.pix.height = height;//视频帧高度
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB565;  //像素格式
    if (0 > ioctl(v4l2_fd, VIDIOC_S_FMT, &fmt)) {
        fprintf(stderr, "ioctl error: VIDIOC_S_FMT: %s\n", strerror(errno));
        return -1;
    }

    /*** 判断是否已经设置为我们要求的RGB565像素格式
    如果没有设置成功表示该设备不支持RGB565像素格式 */
    if (V4L2_PIX_FMT_RGB565 != fmt.fmt.pix.pixelformat) {
        fprintf(stderr, "Error: the device does not support RGB565 format!\n");
        return -1;
    }

    frm_width = fmt.fmt.pix.width;  //获取实际的帧宽度
    frm_height = fmt.fmt.pix.height;//获取实际的帧高度
    printf("视频帧大小<%d * %d>\n", frm_width, frm_height);

    /* 获取streamparm */
    streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    ioctl(v4l2_fd, VIDIOC_G_PARM, &streamparm);

    /** 判断是否支持帧率设置 **/
    if (V4L2_CAP_TIMEPERFRAME & streamparm.parm.capture.capability) {
        streamparm.parm.capture.timeperframe.numerator = 1;
        streamparm.parm.capture.timeperframe.denominator = 30;//30fps
        if (0 > ioctl(v4l2_fd, VIDIOC_S_PARM, &streamparm)) {
            fprintf(stderr, "ioctl error: VIDIOC_S_PARM: %s\n", strerror(errno));
            return -1;
        }
    }

    return 0;
}

static int v4l2_init_buffer(void)
{
    struct v4l2_requestbuffers reqbuf = {0};
    struct v4l2_buffer buf = {0};

    /* 申请帧缓冲 */
    reqbuf.count = FRAMEBUFFER_COUNT;       //帧缓冲的数量
    reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    reqbuf.memory = V4L2_MEMORY_MMAP;
    if (0 > ioctl(v4l2_fd, VIDIOC_REQBUFS, &reqbuf)) {
        fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
        return -1;
    }

    /* 建立内存映射 */
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {

        ioctl(v4l2_fd, VIDIOC_QUERYBUF, &buf);
        buf_infos[buf.index].length = buf.length;
        buf_infos[buf.index].start = mmap(NULL, buf.length,
                PROT_READ | PROT_WRITE, MAP_SHARED,
                v4l2_fd, buf.m.offset);
        if (MAP_FAILED == buf_infos[buf.index].start) {
            perror("mmap error");
            return -1;
        }
    }

    /* 入队 */
    for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {

        if (0 > ioctl(v4l2_fd, VIDIOC_QBUF, &buf)) {
            fprintf(stderr, "ioctl error: VIDIOC_QBUF: %s\n", strerror(errno));
            return -1;
        }
    }

    return 0;
}

static int v4l2_stream_on(void)
{
    /* 打开摄像头、摄像头开始采集数据 */
    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    if (0 > ioctl(v4l2_fd, VIDIOC_STREAMON, &type)) {
        fprintf(stderr, "ioctl error: VIDIOC_STREAMON: %s\n", strerror(errno));
        return -1;
    }

    return 0;
}

static void v4l2_read_data(void)
{
    struct v4l2_buffer buf = {0};
    unsigned short *base;
    unsigned short *start;
    int min_w, min_h;
    int j;

    if (width > frm_width)
        min_w = frm_width;
    else
        min_w = width;
    if (height > frm_height)
        min_h = frm_height;
    else
        min_h = height;

    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for ( ; ; ) {

        for(buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {

            ioctl(v4l2_fd, VIDIOC_DQBUF, &buf);     //出队
            for (j = 0, base=screen_base, start=buf_infos[buf.index].start;
                        j < min_h; j++) {

                memcpy(base, start, min_w * 2); //RGB565 一个像素占2个字节
                base += width;  //LCD显示指向下一行
                start += frm_width;//指向下一行数据
            }

            // 数据处理完之后、再入队、往复
            ioctl(v4l2_fd, VIDIOC_QBUF, &buf);
        }
    }
}

int main(int argc, char *argv[])
{
    if (2 != argc) {
        fprintf(stderr, "Usage: %s \n", argv[0]);
        exit(EXIT_FAILURE);
    }

    /* 初始化LCD */
    if (fb_dev_init())
        exit(EXIT_FAILURE);

    /* 初始化摄像头 */
    if (v4l2_dev_init(argv[1]))
        exit(EXIT_FAILURE);

    /* 枚举所有格式并打印摄像头支持的分辨率及帧率 */
    v4l2_enum_formats();
    v4l2_print_formats();

    /* 设置格式 */
    if (v4l2_set_format())
        exit(EXIT_FAILURE);

    /* 初始化帧缓冲:申请、内存映射、入队 */
    if (v4l2_init_buffer())
        exit(EXIT_FAILURE);

    /* 开启视频采集 */
    if (v4l2_stream_on())
        exit(EXIT_FAILURE);

    /* 读取数据:出队 */
    v4l2_read_data();       //在函数内循环采集数据、将其显示到LCD屏

    exit(EXIT_SUCCESS);
}

编译生成App文件放到板子里。

三、上机实验

  • 驱动模块.ko就绪
  • 应用程序app就绪
    程序运行效果如下图,littlebear_pro的摄像头部分调试结束:
    LittleBear-原子源码驱动ov5640_第2张图片

你可能感兴趣的:(手工制作DIY,linux,arm)