嵌入式综合实验报告

基于OV511芯片的摄像头图像采集显示系统

【实验目的】

1、掌握OV511摄像头和V4L视频驱动的配置方法。

2、掌握JPEG的交叉编译与移植的过程。

3、掌握帧缓冲编程原理以及利用帧缓冲显示图像的编程方法。

【实验原理】

USB摄像头以其良好的性能和低廉的价格得到广泛应用。同时因其灵活、方便的特性，易于集成到嵌入式系统中，现有的符合Video for Linux标准的驱动程序配合通用应用程序，可以实现USB摄像头视频数据的采集及应用开发。

摄像头属于视频类设备。在目前的Linux核心中，视频部分的标准是Video for Linux(简称V4L)。这个标准其实定义了一套接口，内核、驱动、应用程序以这个接口为标准进行交流。目前的V4L涵盖了视、音频流捕捉及处理等内容，USB摄像头也属于它支持的范畴。

1、Video4Linux和USB摄像头驱动配置

如果需要在Linux操作系统中使用USB摄像头进行视频数据采集，则必须在进行内核配置时，应检查Linux 内核中是否已经添加了对Video4Linux驱动和对USB摄像头驱动模块的支持。

本实验采用静态加载驱动。

首先切换linux源代码所在的目录，并终端输入make menuconfig，系统弹出基于Ncurses 内核配置图形界面（如图1所示），便可进行内核选项的配置。

图1内核配置主界面

1.1、配置界面的使用方法

（1）、在菜单方式的配置界面上可用上下方向键来在各菜单之间移动；

（2）、在标有"---->" 标志的地方按回车键进入下级菜单；

（3）、按两次或选择则返回到上级菜单；

（4）、按“h” 键或选择下面的则可看到配置帮助信息；

（5）、按 键则在各控制选项之间移动；

（6）、Y表示包含该功能选项配置在内核中，M表示以模块的方式编译到内核中，N表示该功能选项不进行编译；

（7）、设置状态在[ ] 或< > 中以“ * “(选择), “ M “ (模块), 空格(除外)来表示。

1.2、Video4Linux驱动配置

对Video4Linux支持驱动进行配置，选中多媒体设备选项“Multimedia device－>”（如图1-1所示）按回车，进入多媒体设备配置界面（如图2所示），在多媒体配置界面中，选中“Video For Linux”，加载video4linux模块，就可以使内核实现对Video4Linux驱动的支持，为视频采集设备提供编程接口。

图2 内核配置－多媒体设备配置界面

1.3、USB驱动配置

配置好内核对Video4Linux驱动后，返回内核配置主界面，选中USB支持选项（如图3 所示）“USB support—>”按回车，进入USB支持配置界面。

图3 内核配置主界面－USB支持

在USB支持配置界面中，选中“USB Multimedia device”选项下的“USB OV511 Camera support”，使内核中加入OV511接口芯片的USB数字摄像头的驱动支持。（如图4 所示）。

图4 OV511 USB 摄像头驱动配置界面

2、JPEG的交叉编译与移植

本实验为了节省有限的存储空间，将数据帧转为JPEG格式存储，为了支持对实验过程中生成的JPEG格式图片的各种操作，例如将JPEG格式的图片转为BMP格式图片显示时，需要JPEG的交叉编译与移植。在移植前，需要找到libjpeg，可以在以下网址下载：https://www.360docs.net/doc/4215064013.html,/source/libjpeg/libjpeg-6b.tar.gz。

jpeg的交叉编译与移植的过程如下：

tar -zxvf libjpeg-6b.tar.gz

cd libjpeg-6b

./configure --enable-shared --enable-static --prefix=/usr/local/arm/3.4.5/arm-linux --build=i386 --host=arm

然后修改生成的Makefile

gedit Makefile

cc =gcc 改为CC=arm-linux-gcc

AR=ar rc 改为AR=arm-linux-ar rc

AR2=ranlib 改为AR2=arm-linux-rablib

make

make install-lib

然后在当前的目录下

ls –a

cd .libs

ls

会出现图5所示的结果，这就是需要移植到目标板上面的文件。

图5

把libjpeg.a、https://www.360docs.net/doc/4215064013.html,、libjpeg.so、libjpeg.so.62、libjpeg.so.62.0.0拷到目标板的/lib目录下，把cjpeg、djpeg拷到目标板的/bin目录下就完成了jpeg的交叉编译与移植。

3、帧缓冲编程原理以及利用帧缓冲显示图像

在PC上面仿真的时候需要开启并使用帧缓冲设备。

3.1、帧缓冲编程原理

帧缓冲（framebuffer）是Linux为显示设备提供的一个接口，把显存抽象后的一种设备，它允许上层应用程序在图形模式下直接对显示缓冲区进行读写操作。这种操作是抽象的，统一的。用户不必关心物理显存的位置、换页机制等等具体细节。这些都是由Framebuffer设备驱动来完成的。

Linux FrameBuffer 本质上只是提供了对图形设备的硬件抽象，在开发者看来，FrameBuffer 是一块显示缓存，往显示缓存中写入特定格式的数据就意味着向屏幕输出内容。所以说FrameBuffer就是一块白板。例如对于初始化为16 位色的FrameBuffer 来说，FrameBuffer中的两个字节代表屏幕上一个点，从上到下，从左至右，屏幕位置与内存地址是顺序的线性关系。

帧缓存可以在系统存储器(内存)的任意位置，视频控制器通过访问帧缓存来刷新屏幕。帧缓存也叫刷新缓存Frame buffer 或refresh buffer, 这里的帧(frame)是指整个屏幕范围。

帧缓存有个地址，是在内存里。我们通过不停的向frame buffer中写入数据，显示控制器就自动的从frame buffer中取数据并显示出来。全部的图形都共享内存中同一个帧缓存。

CPU指定显示控制器工作，则显示控制器根据CPU的控制到指定的地方去取数据和指令，目前的数据一般是从显存里取，如果显存里存不下，则从内存里取，内存也放不下，则从硬盘里取，当然也不是内存放不下，而是为了节省内存的话，可以放在硬盘里，然后通过指令控制显示控制器去取。帧缓存Frame Buffer，里面存储的东西是一帧一帧的，显卡会不停的刷新Frame Buffer, 这每一帧如果不捕获的话，则会被丢弃，也就是说是实时的。这每一帧不管是保存在内存还是显存里，都是一个显性的信息，这每一帧假设是800x600的分辨率，则保存的是800x600个像素点和颜色值。

显示器可以显示无限种颜色，目前普通电脑的显卡可以显示32位真彩、24位真彩、16位增强色、256色。除256色外，大家可以根据自己的需要在显卡的允许范围之内随意选择。很多用户有一种错误概念，认为256色是最高级的选项，而实际上正好相反。256色是最低级的选项，它已不能满足彩色图像的显示需要。16位不是16种颜色，而是2的16次平方(256×256)种颜色，但256色就是256(2的8次平方)种颜色。所以16位色要比256色丰富得多。

帧缓冲设备对应的设备文件为/dev/fb*，如果系统有多个显示卡，Linux下还可支持多个帧缓冲设备，最多可达32 个，分别为/dev/fb0到/dev/fb31，而/dev/fb则为当前缺省的帧缓冲设备，通常指向/dev/fb0。当然在嵌入式系统中支持一个显示设备就够了。帧缓冲设备为标准字符设备，主设备号为29，次设备号则从0到31。分别对应/dev/fb0-/dev/fb31。通过/dev/fb，应用程序的操作主要有这几种：

（1）读/写（read/write）/dev/fb：相当于读/写屏幕缓冲区。例如用cp /dev/fb0 tmp命令可将当前屏幕的内容拷贝到一个文件中，而命令cp tmp > /dev/fb0 则将图形文件tmp显示在屏幕上。

（2）映射（map）操作：由于Linux工作在保护模式，每个应用程序都有自己的虚拟地址空间，在应用程序中是不能直接访问物理缓冲区地址的。为此，Linux在文件操作

file_operations结构中提供了mmap函数，可将文件的内容映射到用户空间。对于帧缓冲设备，则可通过映射操作，可将屏幕缓冲区的物理地址映射到用户空间的一段虚拟地址中，之后用户就可以通过读写这段虚拟地址访问屏幕缓冲区，在屏幕上绘图了。实际上，使用帧缓冲设备的应用程序都是通过映射操作来显示图形的。由于映射操作都是由内核来完成，下面我们将看到，帧缓冲驱动留给开发人员的工作并不多。

（3）I/O控制：对于帧缓冲设备，对设备文件的ioctl操作可读取/设置显示设备及屏幕的参数，如分辨率，显示颜色数，屏幕大小等等。ioctl的操作是由底层的驱动程序来完成的。

在本实验中，使用内存映射（mmap）将帧缓冲设备中的屏幕缓冲区映射到进程中的一段虚拟地址空间，接着，通过读写该虚拟地址来访问屏幕缓冲区，实现在屏幕上绘图或者保存屏幕上的绘图信息等操作。

3.2、帧缓冲设备的开启

（1）只需要将/etc/grub.conf改成如下形式就行了(加粗那一行中的vga=0x314是修改过的): # grub.conf generated by anaconda

# Note that you do not have to rerun grub after making changes to this file

# NOTICE: You do not have a /boot partition. This means that

# all kernel and initrd paths are relative to /, eg.

# root (hd0,0)

# kernel /boot/vmlinuz-version ro root=/dev/sda1

# initrd /boot/initrd-version.img

#boot=/dev/sda

default=0

timeout=10

splashimage=(hd0,0)/boot/grub/splash.xpm.gz

title Red Hat Linux (2.4.18-14)

root (hd0,0)

kernel /boot/vmlinuz-2.4.18-14 ro root=LABEL=/ hdc=ide-scsi vga=0x314

其中

（2）设置完成后，重启系统，会发现启动过程中出现一个企鹅的图标，说明修改成功，已经启动帧缓冲设备。

【实验仪器】

1、装有Linux操作系统的PC机一台；

2、XSBase270或XSBase255 ARM实验开发平台一套

【实验内容】

在Linux下，利用基于OV511芯片的摄像头进行图像采集，把采集到的图片以.JPEG，BMP两种格式进行存储，并把采集到的图像循环显示在LCD上。

1、编译内核，静态加载Video4Linux和USB摄像头驱动；

2、交叉编译移植JPEG库，如图6所示；

图6 JPEG库移植

3、开启帧缓冲设备，以实现在PC上的仿真；

4、编辑及编译源代码，生成目标板的可执行文件，如图7所示。

图7 编译源代码并生成可执行文件

5、启动minicom，把生成的test文件传送到目标板

（1）在超级终端输入指令：chmod +x test

（2）在超级终端输入指令：./test

（3）运行程序，按提示进行操作，即可以实现摄像头的图像采集及显示。显示效果如图8和图9所示。

图8 LCD显示1

图9 LCD显示2

【编程指南】

采用系统功能模块化设计。系统包括图像采集模块，图像存储模块以及图像显示模块。下面分别介绍三大模块的实现流程。

1、图像采集模块

1.1 图像采集的编程流程

（1）打开图像设备

（2）读取设备信息

（3）更改设备当前设置

（4）进行图像采集：内存映射

（5）对采集的图像进行处理

（6）关闭视频设备。

1.2 图像采集所定义的数据结构及使用函数

struct _v4l_struct

{

int fd;

struct video_capability capability;

struct video_buffer buffer;

struct video_window window;

struct video_channel channel[8];

struct video_picture picture;

struct video_mmap mmap;

struct video_mbuf mbuf;

unsigned char *map;

};

typedef struct _v4l_struct v4l_device;

extern int v4l_open(char *, v4l_device *);

extern int v4l_close(v4l_device *);

extern int v4l_get_capability(v4l_device *);

extern int v4l_set_norm(v4l_device *, int);

extern int v4l_get_picture(v4l_device *);

extern int v4l_grab_init(v4l_device *, int, int);

extern int v4l_grab_frame(v4l_device *, int);

extern int v4l_grab_sync(v4l_device *);

extern int v4l_mmap_init(v4l_device *);

extern int v4l_get_mbuf(v4l_device *);

extern int v4l_get_picture(v4l_device *);

extern int v4l_grab_picture(v4l_device *, unsigned int);

extern int v4l_set_buffer(v4l_device *);

extern int v4l_get_buffer(v4l_device *);

extern int v4l_switch_channel(v4l_device *, int);

1.3 Video4linux支持的数据结构及其用途

（1）video_capability 包含设备的基本信息（设备名称、支持的最大最小分辨率、信号源信息等）

name[32]（设备名称）、maxwidth、maxheight、minwidth、minheight、Channels（信号源个数）、type （是否能capture），彩色还是黑白，是否能裁剪等，如VID_TYPE_CAPTURE 等。

（2）video_picture 设备采集的图象的各种属性

Brightness 0~65535

hue

colour

contrast

whiteness

depth 8 16 24 32

palette VIDEO_PALETTE_RGB24 | VIDEO_PALETTE_RGB565|VIDEO_PALETTE_JPEG| VIDEO_PALETTE_RGB32

（3）video_channel 关于各个信号源的属性

Channel 信号源的编号

name

tuners

Type VIDEO_TYPE_TV | IDEO_TYPE_CAMERA

Norm 制式PAL|NSTC|SECAM|AUTO

（4）video_window 包含关于capture area的信息

x（x windows中的坐标）、y（y windows中的坐标）、width（捕获图像的宽度）、height（捕获图像的高度）、chromakey（A host order RGB32 value for the chroma key）、flags（Additional capture flags）、clips A list of clipping rectangles. (只能设置)、clipcount The number of clipping rectangles. (只能设置)。

（5）video_mbuf 利用mmap进行映射的帧的信息

size 每帧大小、Frames 最多支持的帧数、Offsets 每帧相对基址的偏移。

（6）video_mmap 用于内存映射

1.4 关键步骤介绍

（1）打开视频：

int v4l_open(char *dev, v4l_device *vd)

{

if (!dev)

dev = ”/dev/video0”;

if ((vd ->fd = open(dev, O_RDWR)) < 0) {

perror("v4l_open:");

return -1;

}

if (v4l_get_capability(vd))

return -1;

if (v4l_get_picture(vd))

retu rn -1;

return 0;

}

（2）读video_capability 中信息

int v4l_get_capability(v4l_device *vd)

{

if (ioctl(vd ->fd, VIDIOCGCAP, &(vd->capability)) < 0) {

perror("v4l_get_capability:");

return -1;

}

return 0;

}

成功后可读取vd->capability各分量。

（3）读video_picture中信息

int v4l_get_picture(v4l_device *vd)

{

if (ioctl(vd ->fd, VIDIOCGPICT, &(vd->picture)) < 0) {

perror("v4l_get_picture:");

return -1;

}

return 0;

}

成功后可读取图像的属性。

（4）改变video_picture中分量的值（可以不做的）

先为分量赋新值，再调用VIDIOCSPICT

vd->picture.colour = 65535;

if(ioctl(vd->fd, VIDIOCSPICT, &(vd->picture)) < 0)

{

perror("VIDIOCSPICT");

return -1;

}

（5）初始化channel

必须先做得到vd->capability中的信息

int v4l_get_channels(v4l_device *vd)

{

int i;

for (i = 0; i < vd ->capability.channels; i++) {

vd ->channel[i].channel = i;

if (ioctl(vd ->fd, VIDIOCGCHAN, &(vd->channel[i])) < 0) {

perror("v4l_get_channel:");

return -1;

}

}

return 0;

}

（6）关闭设备

int v4l_close(v4l_device *vd)

{

close(vd ->fd);

return 0;

}

（6）用mmap（内存映射）方式截取视频

mmap( )系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以向访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、

B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝。

1）设置picture的属性

2）初始化video_mbuf，以得到所映射的buffer的信息

ioctl(vd->fd, VIDIOCGMBUF, &(vd->mbuf))

3）可以修改video_mmap和帧状态的当前设置

4）将mmap与video_mbuf绑定

void* mmap ( void * addr , size_t len , int prot , int flags , int fd , off_t offset )

其中：len：映射到调用进程地址空间的字节数，它从被映射文件开头offset个字节开始算起；

Prot：指定共享内存的访问权限PROT_READ（可读）, PROT_WRITE（可写）,PROT_EXEC （可执行）；

Flags：MAP_SHARED MAP_PRIVATE中必选一个，MAP_ FIXED不推荐使用；

Addr：共内存享的起始地址，一般设0，表示由系统分配

Mmap( ) 返回值是系统实际分配的起始地址

int v4l_mmap_init(v4l_device *vd)

{

if (v4l_get_mbuf(vd) < 0)

return -1;

if ((vd ->map = mmap(0, vd->mbuf.size, PROT_READ|PROT_WRITE,

MAP_SHARED, vd->fd, 0)) < 0) {

perror("v4 l_mmap_init:mmap");

return -1;

}

return 0;

}

5）Mmap方式下真正做视频截取的VIDIOCMCAPTURE

ioctl(vd->fd, VIDIOCMCAPTURE, &(vd->mmap)) ;

若调用成功，开始一帧的截取，是非阻塞的，是否截取完毕留给VIDIOCSYNC来判断。

6）调用VIDIOCSYNC等待一帧截取结束

if(ioctl(vd->fd, VIDIOCSYNC, &frame) < 0)

{

perror("v4l_sync:VIDIOCSYNC");

return -1;

}

若成功，表明一帧截取已完成。可以开始做下一次VIDIOCMCAPTURE。frame是当前截取的帧的序号。

2、图像存储模块

图像存储模块主要包括get_time()以及write_jpeg()函数。

2.1 get_time()函数

用于获取系统时间，并生成两个以当前时间为名字的文件名，例如21_54_19.bmp，21_54_19.jpeg，为保存图片做准备。

2.2 write_jpeg()函数

用于实现把保存在数据帧的图像资料，压缩为GPEG格式的图像。然后再利用djpeg指令

生成相应的BMP格式文件。

2.3 存储时将BGR流转换为RGB流

经过摄像头采集的图像的通道排列顺序为BGR，如果想保存为JPEG格式的文件，需要在压缩前将其顺序先按RGB排列，然后压缩再保存成JPEG格式的文件。具体的转换方法为：

image_buffer = tmp = (unsigned char *)map + m_buf.offsets[frame];

for(i =0;i

for(j=0;j

{

buf = *tmp;

*tmp = *(tmp+2);

*(tmp+2) = buf;

tmp += 3;

}

其中image_buf为采集的数据，在此只需要将指向R和B的指针互调一下就行，经过处理重新得到的image_buf为RGB排列。

2.4 程序中代码

write_jpeg(NAME,img,90,NTSC_WIDTH,NTSC_HEIGHT,0);

char mingling[300]="djpeg -bmp -outfile ";

sprintf(mingling,"djpeg -bmp -outfile %s %s",NAME1,NAME);

printf("%s\n",mingling);

system(mingling); //调用系统指令djpeg，需要移植djpeg到/bin目录（见JPEG的交叉编译与移植）

3 图像显示模块

3.1 图像显示编程流程

（1）打开/dev/fb设备文件。

（2）用ioctrl操作取得当前显示屏幕的参数，如屏幕分辨率，每个像素点的比特数。根据屏幕参数可计算屏幕缓冲区的大小。

（3）将屏幕缓冲区映射到用户空间。

（4）映射后就可以直接读写屏幕缓冲区，进行绘图和图片显示了。

3.2 程序段

struct fb_var_screeninfo vinfo; //记录帧设备和指定显示模式的不可修改的信息

struct fb_fix_screeninfo finfo; //记录帧缓冲设备和指定显示模式的可修改的信息

long int location=0; //初始化显示的位置

ioctl(fbfd, FBIOGET_FSCREENINFO, &finfo); //获取帧设备和指定显示模式的不可修改的信息

ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo); //获取帧缓冲设备和指定显示模式的可修改的信息

screensize = vinfo.xres * vinfo.yres * vinfo.bits_per_pixel / 8; //计算帧缓冲数据区大小

fbp=(char*)mmap(0,screensize,PROT_READ|PROT_WRITE,MAP_SHARED, fbfd, 0); //内存映射

memset(fbp,0,screensize); //清屏

bmpshow(NAME1,fbp); //将图片送到显存，该函数的具体实现请看源程序

munmap(fbp,screensize);

close(fbfd);

3.3 消除显示过程中的失真

在利用djpeg指令将JPEG格式的图片转换为BMP格式的图像进行显示时，需要行调整才能实现图片的无失真显示。具体方法为（部分代码，具体见附录）：

struct colors

{

char red;

char blue;

char green;

//char Reserved;

}co124;//将JPEG转换为BMP文件中的RGB读到此结构体中

blue=(unsigned int)((co124.blue>>3)&31);

green=(unsigned int)((co124.green>>2)&63);

red=(unsigned int)((co124.red>>3)&31);

*((unsigned long int*)(fbp+location))=blue|green<<5|red<<11;//location为每一个像素点的位置，fbp为指向BMP文件的指针，实现每一个像素点的RGB值的调整

【总结】

通过本次综合实验，我掌握了（1）内核的编译，实现了Video4Linux和USB摄像头驱动的静态加载；（2）库文件的交叉编译与移植，实现了JPEG的交叉编译与移植；（3）V4L 的编程思想，实现了视频图像的采集；（3）帧缓冲设备的使用，利用帧缓冲设备实现图像的显示；（4）将摄像头采集的BRG流转为RGB流，实现图像的正常显示以及JPEG格式图片的保存。在本次实验中也遇到了一些困难，（1）将JPEG格式转为BMP格式的图片中的困难，主要问题在于JPEG的移植过程中，有一些文件无法传到目标板上，原因在于存储空间不足，删除一些无用的文件之后就可以实现了；（2）将图像无失真的显示的困难，主要是因为经过摄像头采集的图像的通道排列顺序为BGR，如果你想保存为JPEG格式的文件，需要在压缩前将其顺序先按RGB排列，然后压缩再保存成JPEG格式的文件。再者在显示通过JPEG转换而来的BMP图像时，需要调整每一个像素点的RGB值，以使图像能够无失真的显示。当然本次实验还存在一些不足和需要改进的地方，比如没有必要存储BMP格式的图像，可以只是存储JPEG格式，待要显示时，在对JPEG格式的图像进行实时的转换和显示，以节省存储空间，当然这只需要在代码上稍加改动即可实现；再者就是没有实现使用QT编译的图像采集界面等，这些都是值得改进的地方。

【附录】

本实验主要源代码的源代码如下。

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include "v4l.h"

#include "v4lctoh.h"

#define norm VIDEO_MODE_NTSC

/*typedef struct _v4l_struct v4l_device;*/

v4l_device vd;

int count=0;

char NAME[100]="/home/"; //定义.jpeg图片的存放地址

char NAME1[100]="/Documents/"; //定义.bmp图片的存放地址

char base[100]="/home/"; //作为一个临时的变量

char NAME_TOTAL[10][100];

int temp=0;

struct fb_var_screeninfo vinfo; //用于记录帧缓冲设备和指定的显示模式的可修改的信息struct fb_fix_screeninfo finfo; //用于记录帧缓冲设备和指定的显示模式的不可修改的信息long int location=0; //显示定位

/*保存影像到frame里面*/

int device_grab_frame()

{

vd.frame_current =0;

if (v4l_grab_frame(&vd,0)<0)

return -1;

return 0;

}

int device_next_frame()

{

vd.frame_current ^=1;

if(v4l_grab_frame(&vd,vd.frame_current)<0)

return -1;

return 0;

}

/*返回frame的地址*/

unsigned char *device_get_address()

{

int i,j;

unsigned char *image_buffer="";

unsigned char *tmp="";

image_buffer = tmp = vd.map +vd.mbuf.offsets[vd.frame_current];

/*经过摄像头采集的图像通道排列为BGR,但是保存为jpeg格式时要将其顺序改变为RGB*/

for(i =0;i

for(j=0;j

{

int buf = *tmp;

*tmp = *(tmp+2);

*(tmp+2) = buf;

tmp += 3;

}

return (image_buffer);

// return (vd.map +vd.mbuf.offsets[vd.frame_current]);

}

/*初始化,打开设备,获取设备采集图片的各种属性,各个信号源的属性*/

int device_init(char *dev)

{ if (dev==NULL)

dev = "/dev/video0";

if (v4l_open(dev,&vd)!=0) // initial set 1

return -1;

if(v4l_get_picture(&vd)!=0) // initial set 2

return -1;

if(v4l_get_channels(&vd)!=0) // initial set 3

return -1;

printf("%s:initialization OK...%s\n"

"%d channels \n"

"%d audios \n",

dev,https://www.360docs.net/doc/4215064013.html,,vd.capability.channels,vd.capability.audios);

return 0;

}

/*获取系统时间,作为.bmp ,jpeg文件的文件名*/

int get_time()

{

struct tm *ptm;

char str[30];

time_t rawtime;

time (&rawtime);

ptm = localtime(&rawtime);

sprintf(str,"%d_%d_%d",ptm->tm_hour, ptm->tm_min, ptm->tm_sec);

char *shuxing=".jpeg";

char *shuxing1=".bmp";

sprintf(NAME,"%s%s%s",NAME,str,shuxing);//.jpeg的文件名

sprintf(NAME1,"%s%s%s",NAME1,str,shuxing1);//.bmp图片的文件名

}

/*将rgb流转化为.jpeg格式图片*/

int write_jpeg(char *filename,unsigned char *buf,int quality,int width, int height, int gray) {

struct jpeg_compress_struct cinfo;

struct jpeg_error_mgr jerr;

FILE *fp;

int i;

unsigned char *line;

int line_length;

fp = fopen(filename,"w");

cinfo.err = jpeg_std_error(&jerr);

jpeg_create_compress(&cinfo);

jpeg_stdio_dest(&cinfo, fp);

cinfo.image_width = width;

cinfo.image_height = height;

cinfo.input_components = gray ? 1: 3;

cinfo.in_color_space = gray ? JCS_GRAYSCALE: JCS_RGB;

jpeg_set_defaults(&cinfo);

jpeg_set_quality(&cinfo, quality, TRUE);

jpeg_start_compress(&cinfo, TRUE);

line_length = gray ? width : width * 3;

for (i = 0, line = buf; i < height; i++, line += line_length)

jpeg_write_scanlines(&cinfo, &line, 1);

jpeg_finish_compress(&(cinfo));

jpeg_destroy_compress(&(cinfo));

fclose(fp);

return 0;

}

/*摄像头采集图片,并将采集到的图片保存为.jpeg格式的图片,把图片显示在LCD上面*/ int v41_capture()

{

int total=0;

unsigned char *img="";

printf("please enter the number of picture you want to capture \n");

scanf("%d",&total);

temp=total;

while(count

{

printf("If you are ready to capture picture,please enter a num \n");

int num=0;

scanf("%d",&num);

if(device_grab_frame()!=0)

return -1;

else

printf("v4l_grab_frame :OK \n");

if(device_next_frame()!=0)

return -1;

else

printf("v4l_grab_frame_next frame ready...: OK \n");

if(v4l_grab_sync(&vd)!=0)

return -1;

else

printf("v4l_grab_sync : OK \n");

img= device_get_address();//返回所采集的数据的起始地址

get_time();//获得图片的名字

write_jpeg(NAME,img,90,NTSC_WIDTH,NTSC_HEIGHT,0);//保存采集到的图片

char mingling[300]="djpeg -bmp -outfile ";

sprintf(mingling,"djpeg -bmp -outfile %s %s",NAME1,NAME);

printf("%s\n",mingling);

system(mingling);//保存.bmp格式的图片,用于LCD显示

sprintf(NAME_TOTAL[count],"%s",NAME1);

int fbfd ;

long int screensize = 0;

char *fbp;

fbfd = open("/dev/fb0", O_RDWR); //打开帧缓冲设备

printf("fbfd=%d\n",fbfd);

if(fbfd<=0)

{

printf("can not open fb0\n");

return -1;

}

/*获取帧缓冲设备的信息*/

ioctl(fbfd, FBIOGET_FSCREENINFO, &finfo);

ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo);

screensize = vinfo.xres * vinfo.yres * vinfo.bits_per_pixel / 8; //计算帧缓冲数据区大小

fbp=(char*)mmap(0,screensize,PROT_READ|PROT_WRITE,MAP_SHARED, fbfd, 0); //内存映射

memset(fbp,0,screensize);//清屏

bmpshow(NAME1,fbp);//将图像数据送到显存

munmap(fbp,screensize);

close(fbfd);

/*采集一幅图像后重新初始化基本变量*/

vd.frame_current=0;

strcpy(NAME,base);

strcpy(NAME1,base);

count=count+1;

printf("%d %d\n",count,total);

}

while(1)

{

int show;

for(show=0;show

{

bmpshow_total(NAME_TOTAL[show]);

sleep(2);

}

}

}

int bmpshow_total(char *filename2)

{

int fbfd_total ;

long int screensize_total = 0;

char *fbp_total;

fbfd_total = open("/dev/fb0", O_RDWR); //打开帧缓冲设备

printf("fbfd=%d\n",fbfd_total);

if(fbfd_total<=0)

{

printf("can not open fb0\n");

return -1;

}

/*获取帧缓冲设备的信息*/

ioctl(fbfd_total, FBIOGET_FSCREENINFO, &finfo);

ioctl(fbfd_total, FBIOGET_VSCREENINFO, &vinfo);

screensize_total = vinfo.xres * vinfo.yres * vinfo.bits_per_pixel / 8; //计算帧缓冲数据区大小

fbp_total=(char*)mmap(0,screensize_total,PROT_READ|PROT_WRITE,MAP_SHARED,

fbfd_total, 0); //内存映射

memset(fbp_total,0,screensize_total);//清屏

bmpshow(filename2,fbp_total);//将图像数据送到显存

munmap(fbp_total,screensize_total);

close(fbfd_total);

}

/*显示图像*/

int bmpshow(char *filename1,unsigned char *fbp)

{

FILE *fp1;

int width,height;

int blue,green,red;

int x=0,y=0;

struct colors

{

char red;

char blue;

char green;

//char Reserved;

}co124;

fp1=fopen(filename1,"rb");

printf("filename1=%s\n",filename1);

printf("fp1=%d\n",fp1);

fseek(fp1,18L,0);//定位到文件的第18字节处以确定图片的宽与高

fread(&width,sizeof(width),1,fp1);//读出4字节为图片宽

fread(&height,sizeof(height),1,fp1);//读出4字节为图片高

printf("width=%d,height=%d\n",width,height);

for(y=height+120-1;y>=120;y--)

{

for(x=160;x

{

//定位每个象素点

location=(x+vinfo.xoffset)*(vinfo.bits_per_pixel/8)+(y+vinfo.yoffset)*finfo.line_length;

//显示

if(fread(&co124,3,1,fp1)!=1)

{

printf("file read error\n");

break;

}

blue=(unsigned int)((co124.blue>>3)&31);

green=(unsigned int)((co124.green>>2)&63);

red=(unsigned int)((co124.red>>3)&31);

*((unsigned long int*)(fbp+location))=blue|green<<5|red<<11;

// printf("b=%d g=%d r=%d ",blue,green,red);

// *((unsigned long int*)(fbp+location))=((red>>3)<<11)|((green>>2)<<5)|(blue>>3);

// *((unsigned long int*)(fbp+location))=(blue>>3)|((green>>2)<<5)|((red>>3)<<11);

// *((unsigned long int*)(fbp+location))=blue<<3|green<<2|red<<3 ;

// *((unsigned long int*)(fbp+location))=blue ;

// *((unsigned long int*)(fbp+location+1))=green ;

// *((unsigned long int*)(fbp+location+2))=red ;

}

}

fclose(fp1);

return 0;

}

int main()

{

int frame=0;//初始化保存数据帧的位置

//设备初始化

if (device_init("/dev/video0")==-1)

{

perror("device_init:failed ....");

exit(1);

}

else

printf("device_init: OK \n");

//设定norm

if(v4l_set_norm(&vd, norm)!=0)

return -1;

else

printf("v4l_set_norm: OK \n");

//内存映射

if(v4l_mmap_init(&vd)!= 0)

return -1;

else

printf("v4l_mmap_init: OK \n");

//初始化要采集的图像的相关信息,例如宽,高等

if(v4l_grab_init(&vd,NTSC_WIDTH,NTSC_HEIGHT)!= 0)

return -1;

else

printf("v4l_grab_init: OK \n");

//等待采集结束