《STM32H562开发指南 V1.0 》第四十七章 照相机实验

正点原子运营

第四十七章 照相机实验

1）实验平台：正点原子Mini STM32H562开发板

2）章节摘自【正点原子】STM32H562开发指南 V1.0

3）购买链接： https://detail.tmall.com/item.htm?id=753606659612

4）全套实验源码+手册+视频下载地址：http://www.openedv.com/docs/boards/stm32/zdyz_stm32h562_mini.html

5）正点原子官方B站：https://space.bilibili.com/394620890

6）正点原子STM32开发板技术交流群：414052738





上一章，我们学习了图片解码，本章我们将学习BMP&JPEG编码，结合前面的摄像头实验，实现一个简单的照相机。
本章分为如下几个小节：
47.1 BMP&JPEG编码简介
47.2 硬件设计
47.3 程序设计
47.4下载验证

47.1 BMP&JPEG编码简介
我们要实现支持BMP图片格式的照片和JPEG图片格式的照片的照相机功能，这里简单介绍一下这两种图片格式的编码。这里我们使用正点原子OV5640-AF摄像头，来实现拍照。关于OV5640的相关知识点，请参考前面的章节。

47.1.1 BMP编码简介
前面的章节中，我们学习了各种图片格式的解码。本章，我们介绍最简单的图片编码方法：BMP图片编码。通过前面的了解，我们知道BMP文件是由文件头、位图信息头、颜色信息和图形数据等四部分组成。我们先来了解下这几个部分。
1、BMP文件头（14字节）：BMP文件头数据结构含有BMP文件的类型、文件大小和位图起始位置等信息。  
这里的__PACKED_STRUCT是强制对齐，这里是把结构体中间的留白空间移除。默认定义的变量是按CPU字长（STM32为32位）对齐的，这样可以增加程序的访问速度，但这样定义一个结构体时如果结构体成员并不全部按CUP的字长去定义，如有uint8_t，uint16_t时，编译器默认按照的长度将占用2个uint32_t类型的长度，而对于嵌入式产品尤其是内存紧张的产品，这样定义的结构体变量就会浪费内存空间。嵌入式的编译器支持通过强制对齐，可以优化结构体变量的空间，大家同样可以在MDK的帮助文件中查找__packed关键字去看这部分的知识点。我们这里用了在MDK下同时兼容AC5和AC6编译器的写法。BMP的文件头定义如下：

1. /* BMP头文件 */
   
2. typedef __PACKED_STRUCT
   
3. {
   
4.     uint16_t  bfType;              /* 文件标志.只对'BM',用来识别BMP位图类型 */
   
5.     uint32_t  bfSize;              /* 文件大小,占四个字节 */
   
6.     uint16_t  bfReserved1;         /* 保留 */
   
7.     uint16_t  bfReserved2;         /* 保留 */
   
8.     uint32_t  bfOffBits;           /* 从文件开始到位图数据(bitmap data)开始之间的的偏移量 */
   
9. }BITMAPFILEHEADER ;

复制代码

2、位图信息头（40字节）：BMP位图信息头数据用于说明位图的尺寸等信息。  

1. /* BMP信息头 */
   
2. typedef __PACKED_STRUCT
   
3. {
   
4.     uint32_t biSize;                /* 说明BITMAPINFOHEADER结构所需要的字数。 */
   
5.     long  biWidth;                  /* 说明图象的宽度，以象素为单位 */
   
6.     long  biHeight;                 /* 说明图象的高度，以象素为单位 */
   
7.     uint16_t  biPlanes;             /* 为目标设备说明位面数，其值将总是被设为1 */
   
8.     uint16_t  biBitCount;          /* 说明比特数/象素，其值为1、4、8、16、24、或32 */
   
9.     uint32_t biCompression;        /* 说明图象数据压缩的类型。其值可以是下述值之一
   
10.                                   * BI_RGB  ：没有压缩
    
11.                                        * BI_RLE8 ：每个象素8bit的RLE压缩编码，压缩格式由2B组成
    
12.                                      * BI_RLE4 ：每个象素4bit的RLE压缩编码，压缩格式由2B组成
    
13.                                      * BI_BITFIELDS：每个象素的比特由指定的掩码决定
    
14.                                   */
    
15.     uint32_t biSizeImage;/*说明图象的大小，以字节为单位。当用BI_RGB格式时，可设置为0*/
    
16.     long  biXPelsPerMeter ; /* 说明水平分辨率，用象素/米表示 */
    
17.     long  biYPelsPerMeter ; /* 说明垂直分辨率，用象素/米表示 */
    
18. uint32_t biClrUsed ;    /* 说明位图实际使用的彩色表中的颜色索引数 */
    
19. /* 说明对图象显示有重要影响的颜色索引的数目，如果是0，表示都重要 */
    
20.     uint32_t biClrImportant ;   
    
21. }BITMAPINFOHEADER ;

复制代码

3、颜色表：颜色表用于说明位图中的颜色，它有若干个表项，每一个表项是一个RGBQUAD类型的结构，定义一种颜色。

1. /* 彩色表  */
   
2. typedef __PACKED_STRUCT
   
3. {
   
4.     uint8_t rgbBlue ;                   /* 指定蓝色强度 */
   
5.     uint8_t rgbGreen ;                  /* 指定绿色强度 */
   
6.     uint8_t rgbRed ;                    /* 指定红色强度 */
   
7.     uint8_t rgbReserved ;              /* 保留，设置为0 */
   
8. }RGBQUAD ;

复制代码

颜色表中RGBQUAD结构数据的个数由biBitCount来确定：当biBitCount=1、4、8时，分别有2、16、256个表项；当biBitCount大于8时，没有颜色表项。  
BMP文件头、位图信息头和颜色表组成位图信息（我们将BMP文件头也加进来，方便处理），BITMAPINFO结构定义如下:

1. /* 位图信息头 */
   
2. typedef __PACKED_STRUCT
   
3. {
   
4.     BITMAPFILEHEADER bmfHeader;
   
5.     BITMAPINFOHEADER bmiHeader;  
   
6.     uint32_t RGB_MASK[3];       /* 调色板用于存放RGB掩码 */
   
7.     //RGBQUAD bmiColors[256];
   
8. }BITMAPINFO;

复制代码

4、位图数据：位图数据记录了位图的每一个像素值，记录顺序是在扫描行内是从左到右，扫描行之间是从下到上。位图的一个像素值所占的字节数：
当biBitCount=1时，8个像素占1个字节；
当biBitCount=4时，2个像素占1个字节；
当biBitCount=8时，1个像素占1个字节；
当biBitCount=16时，1个像素占2个字节；
当biBitCount=24时，1个像素占3个字节；
当biBitCount=32时，1个像素占4个字节；
biBitCount=1 表示位图最多有两种颜色，缺省情况下是黑色和白色，你也可以自己定义这两种颜色。图像信息头装调色板中将有两个调色板项，称为索引0和索引1。图象数据阵列中的每一位表示一个像素。如果一个位是0，显示时就使用索引0的RGB值，如果位是1，则使用索引1的RGB值。   
biBitCount=16 表示位图最多有65536种颜色。每个像素用16位（2个字节）表示。这种格式叫作高彩色，或叫增强型16位色，或64K色。它的情况比较复杂，当biCompression成员的值是BI_RGB时，它没有调色板。16位中，最低的5位表示蓝色分量，中间的5位表示绿色分量，高的5位表示红色分量，一共占用了15位，最高的一位保留，设为0。这种格式也被称作555 16位位图。如果biCompression成员的值是BI_BITFIELDS，那么情况就复杂了，首先是原来调色板的位置被三个DWORD变量占据，称为红、绿、蓝掩码。分别用于描述红、绿、蓝分量在16位中所占的位置。在Windows 95（或98）中，系统可接受两种格式的位域：555和565，在555格式下，红、绿、蓝的掩码分别是：0x7C00、0x03E0、0x001F，而在565格式下，它们则分别为：0xF800、0x07E0、0x001F。你在读取一个像素之后，可以分别用掩码“与”上像素值，从而提取出想要的颜色分量（当然还要再经过适当的左右移操作）。在NT系统中，则没有格式限制，只不过要求掩码之间不能有重叠。（注：这种格式的图像使用起来是比较麻烦的，不过因为它的显示效果接近于真彩，而图像数据又比真彩图像小的多，所以，它更多的被用于游戏软件）。
biBitCount=32 表示位图最多有4294967296(2的32次方)种颜色。这种位图的结构与16位位图结构非常类似，当biCompression成员的值是BI_RGB时，它也没有调色板，32位中有24位用于存放RGB值，顺序是：最高位—保留，红8位、绿8位、蓝8位。这种格式也被成为888 32位图。如果 biCompression成员的值是BI_BITFIELDS时，原来调色板的位置将被三个DWORD变量占据，成为红、绿、蓝掩码，分别用于描述红、绿、蓝分量在32位中所占的位置。在Windows 95(or 98)中，系统只接受888格式，也就是说三个掩码的值将只能是：0xFF0000、0xFF00、0xFF。而NT系统，只要注意使掩码之间不产生重叠就行。（注：这种图像格式比较规整，因为它是DWORD对齐的，所以在内存中进行图像处理时可进行汇编级的代码优化（简单）。
通过以上了解，我们对BMP有了一个比较深入的了解，本章，我们采用16位BMP编码（因为我们的LCD就是16位色的，而且16位BMP编码比24位BMP编码更省空间），故我们需要设置biBitCount的值为16，这样得到新的位图信息（BITMAPINFO）结构体：

1. /* 位图信息头 */
   
2. typedef __PACKED_STRUCT
   
3. {
   
4.     BITMAPFILEHEADER bmfHeader;
   
5.     BITMAPINFOHEADER bmiHeader;  
   
6.     uint32_t RGB_MASK[3];       /* 调色板用于存放RGB掩码 */
   
7. }BITMAPINFO;

复制代码

其实就是颜色表由3个RGB掩码代替。最后，我们来看看将LCD的显存保存为BMP格式的图片文件的步骤：
1）创建BMP位图信息，并初始化各个相关信息
这里，我们要设置BMP图片的分辨率为LCD分辨率、BMP图片的大小（整个BMP文件大小）、BMP的像素位数（16位）和掩码等信息。
2）创建新BMP文件，写入BMP位图信息
我们要保存BMP，当然要存放在某个地方（文件），所以需要先创建文件，同时先保存BMP位图信息，之后才开始BMP数据的写入。
3）保存位图数据。
这里就比较简单了，只需要从LCD的GRAM里面读取各点的颜色值，依次写入第二步创建的BMP文件即可。注意：保存顺序（即读GRAM顺序）是从左到右，从下到上。
4）关闭文件。
使用FATFS，在文件创建之后，必须调用f_close，文件才会真正体现在文件系统里面，否则是不会写入的！这个要特别注意，写完之后，一定要调用f_close。
BMP编码就介绍到这里。

47.1.2 JPEG编码简介
JPEG（Joint Photographic Experts Group）是一个由ISO和IEC两个组织机构联合组成的一个专家组，负责制定静态的数字图像数据压缩编码标准，这个专家组开发的算法称为JPEG算法，并且成为国际上通用的标准，因此又称为JPEG标准。JPEG是一个适用范围很广的静态图像数据压缩标准，既可用于灰度图像又可用于彩色图像。
JPEG专家组开发了两种基本的压缩算法，一种是采用以离散余弦变换（Discrete Cosine Transform，DCT）为基础的有损压缩算法，另一种是采用以预测技术为基础的无损压缩算法。使用有损压缩算法时，在压缩比为25:1的情况下，压缩后还原得到的图像与原始图像相比较，非图像专家难于找出它们之间的区别，因此得到了广泛的应用。
JPEG压缩是有损压缩，它利用了人的视角系统的特性，使用量化和无损压缩编码相结合来去掉视角的冗余信息和数据本身的冗余信息。
JPEG压缩编码分为三个步骤：
1）使用正向离散余弦变换（Forward Discrete Cosine Transform，FDCT）把空间域表示的图变换成频率域表示的图。
2）使用加权函数对DCT系数进行量化，这个加权函数对于人的视觉系统是最佳的。
3）使用霍夫曼可变字长编码器对量化系数进行编码。
这里我们不详细介绍JPEG压缩的过程了，大家可以自行查找相关资料。我们本实验要实现的JPEG拍照，并不需要自己压缩图像，因为我们使用的ALIENTEK OV5640摄像头模块，直接就可以输出压缩后的JPEG数据，我们完全不需要理会压缩过程，所以本实验我们实现JPEG拍照的关键，在于准确接收OV5640摄像头模块发送过来的编码数据，然后将这些数据保存为.jpg文件，就可以实现JPEG拍照了。

47.2 硬件设计

1. 例程功能
1、首先是检测字库，然后检测SD卡根目录是否存在PHOTO文件夹，如果不存在则创建，如果创建失败，则报错（提示拍照功能不可用）。在找到SD卡的PHOTO文件夹后，开始初始化OV5640，如果初始化成功，就一直在屏幕显示OV5640拍到的内容。当按下KEY_UP按键时，可以选择缩放还是1:1显示，默认缩放。按下KEY0，可以拍bmp格式照片(分辨率为LCD分辨率)。按下KEY1可以拍JPEG格式照片(分辨率为QSXGA即2592*1944)。拍照保存成功之后，蜂鸣器会发出“滴”的一声，提示拍照成功。
2、LED0闪烁，提示程序运行。LED1用于指示帧中断。

2. 硬件资源
1）LED灯   
       LED0 - PB4   
       LED1 - PB5
2）蜂鸣器
       BEEP - PE0  
3）独立按键 ：
       KEY0 - PA1
       KEY1 - PA15
       WK_UP - PA0
4）串口1(PA9/PA10连接在板载USB转串口芯片CH340上面)
5）正点原子2.8/3.5/4.3/7寸TFTLCD模块(仅限MCU屏，16位8080并口驱动)
6）SD卡，通过SDMMC1(SDMMC_D0~D4(PC8~PC11)，
       SDMMC_SCK(PC12)，SDMMC_CMD(PD2))连接
7）norflash(QSPI FLASH芯片，连接在OSPI上)
8）定时器4
9）ATK-MC5640摄像头模块

47.3 程序设计

47.3.1 程序流程图

图47.3.1.1 照相机实验程序流程图

47.3.2 程序解析

1. PICTURE驱动代码
这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。PICTURE驱动源码包括两个文件：bmp.c和bmp.h。
bmp.h头文件在47.1.1小节基本讲过，具体请看源码。下面来看到bmp.c文件里面的bmp编码函数：bmp_encode，该函数代码如下：

1. /**
   
2. * @brief   BMP编码函数
   
3. *   [url=home.php?mod=space&uid=60778]@note[/url]  将当前LCD屏幕的指定区域截图,存为16位格式的BMP文件 RGB565格式.
   
4. *           保存为rgb565则需要掩码,需要利用原来的调色板位置增加掩码.这里我们已经增加了掩码.
   
5. *           保存为rgb555格式则需要颜色转换,耗时间比较久,所以保存为565是最快速的办法.
   
6. *
   
7. * [url=home.php?mod=space&uid=271674]@param[/url]       filename    : 包含存储路径的文件名(.bmp)
   
8. * @param       x, y         : 起始坐标
   
9. * @param       width,height: 区域大小
   
10. * @param       acolor      : 附加的alphablend的颜色(这个仅对32位色bmp有效!!!)
    
11. * @param       mode        : 保存模式
    
12. *   @arg                     0, 仅仅创建新文件的方式编码;
    
13. *   @arg                     1, 如果之前存在文件,则覆盖之前的文件.如果没有,则创建新的文件;
    
14. * @retval      操作结果
    
15. *   @arg       0   , 成功
    
16. *   @arg       其他, 错误码
    
17. */
    
18. uint8_t bmp_encode(uint8_t *filename, uint16_t x, uint16_t y, uint16_t width,
    
19. uint16_t height, uint8_t mode)
    
20. {
    
21.     FIL *f_bmp;
    
22.     uint32_t bw = 0;
    
23.     uint16_t bmpheadsize;          /* bmp头大小 */
    
24.     BITMAPINFO hbmp;                /* bmp头 */
    
25.     uint8_t res = 0;
    
26.     uint16_t tx, ty;                /* 图像尺寸 */
    
27.     uint16_t *databuf;             /* 数据缓存区地址 */
    
28.     uint16_t pixcnt;               /* 像素计数器 */
    
29.     uint16_t bi4width;            /* 水平像素字节数 */
    
30. 
    
31.     if (width == 0 || height == 0)return PIC_WINDOW_ERR;                 /* 区域错误 */
    
32.     if ((x + width - 1) > lcddev.width)return PIC_WINDOW_ERR;           /* 区域错误 */
    
33.     if ((y + height - 1) > lcddev.height)return PIC_WINDOW_ERR;        /* 区域错误 */
    
34. 
    
35. #if BMP_USE_MALLOC == 1     /* 使用malloc */
    
36.    
    
37. /* 开辟至少bi4width大小的字节的内存区域 ,对240宽的屏,480个字节就够了.
    
38. 最大支持1024宽度的bmp编码 */
    
39. databuf = (uint16_t *)piclib_mem_malloc(2048);
    
40. 
    
41.     if (databuf == NULL)return PIC_MEM_ERR;                     /* 内存申请失败. */
    
42.     f_bmp = (FIL *)piclib_mem_malloc(sizeof(FIL));         /* 开辟FIL字节的内存区域 */
    
43.     if (f_bmp == NULL)      /* 内存申请失败 */
    
44.     {
    
45.         piclib_mem_free(databuf);
    
46.         return PIC_MEM_ERR;
    
47.     }
    
48. #else
    
49.     databuf = (uint16_t *)bmpreadbuf;
    
50.     f_bmp = &f_bfile;
    
51. #endif
    
52.     bmpheadsize = sizeof(hbmp);                                                 /* 得到bmp文件头的大小 */
    
53.     my_mem_set((uint8_t *)&hbmp, 0, sizeof(hbmp));                 /* 置零空申请到的内存 */
    
54.     hbmp.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);         /* 信息头大小 */
    
55.     hbmp.bmiHeader.biWidth = width;             /* bmp的宽度 */
    
56.     hbmp.bmiHeader.biHeight = height;          /* bmp的高度 */
    
57.     hbmp.bmiHeader.biPlanes = 1;                /* 恒为1 */
    
58.     hbmp.bmiHeader.biBitCount = 16;            /* bmp为16位色bmp */
    
59.     hbmp.bmiHeader.biCompression = BI_BITFIELDS; /* 每个象素的比特由指定的掩码决定 */
    
60.     hbmp.bmiHeader.biSizeImage = hbmp.bmiHeader.biHeight
    
61. * hbmp.bmiHeader.biWidth * hbmp.bmiHeader.biBitCount / 8;/* bmp数据区大小 */
    
62. hbmp.bmfHeader.bfType = ((uint16_t)'M' << 8) + 'B';       /* BM格式标志 */
    
63. /* 整个bmp的大小 */
    
64.     hbmp.bmfHeader.bfSize = bmpheadsize + hbmp.bmiHeader.biSizeImage;
    
65.     hbmp.bmfHeader.bfOffBits = bmpheadsize;        /* 到数据区的偏移 */
    
66.     hbmp.RGB_MASK[0] = 0X00F800;                        /* 红色掩码 */
    
67.     hbmp.RGB_MASK[1] = 0X0007E0;                        /* 绿色掩码 */
    
68.     hbmp.RGB_MASK[2] = 0X00001F;                        /* 蓝色掩码 */
    
69. 
    
70.     if (mode == 1)
    
71. {   /* 尝试打开之前的文件 */
    
72.         res = f_open(f_bmp, (const TCHAR *)filename, FA_READ | FA_WRITE);      
    
73.     }
    
74.     if (mode == 0 || res == 0x04)
    
75. {   /* 模式0,或者尝试打开失败,则创建新文件 */
    
76.         res = f_open(f_bmp, (const TCHAR *)filename, FA_WRITE | FA_CREATE_NEW);
    
77.     }
    
78.     if ((hbmp.bmiHeader.biWidth * 2) % 4)   /* 水平像素(字节)不为4的倍数 */
    
79. {   /* 实际要写入的宽度像素,必须为4的倍数 */
    
80.         bi4width = ((hbmp.bmiHeader.biWidth * 2) / 4 + 1) * 4;  
    
81.     }
    
82.     else
    
83.     {
    
84.         bi4width = hbmp.bmiHeader.biWidth * 2;  /* 刚好为4的倍数 */
    
85.     }
    
86. 
    
87.     if (res == FR_OK)   /* 创建成功 */
    
88.     {
    
89.         res = f_write(f_bmp, (uint8_t *)&hbmp, bmpheadsize, &bw);/* 写入BMP首部*/
    
90. 
    
91.         for (ty = y + height - 1; hbmp.bmiHeader.biHeight; ty--)
    
92.         {
    
93.             pixcnt = 0;
    
94.             for (tx = x; pixcnt != (bi4width / 2);)
    
95.             {
    
96.                 if (pixcnt < hbmp.bmiHeader.biWidth)
    
97.                 {
    
98.                     databuf[pixcnt] = pic_phy.read_point(tx, ty);/* 读取坐标点的值 */
    
99.                 }
    
100.                 else
     
101.                 {
     
102.                     databuf[pixcnt] = 0Xffff;   /* 补充白色的像素 */
     
103.                 }
     
104.                 pixcnt++;
     
105.                 tx++;
     
106.             }
     
107.             hbmp.bmiHeader.biHeight--;
     
108.             res = f_write(f_bmp, (uint8_t *)databuf, bi4width, &bw);/* 写入数据 */
     
109.         }
     
110.         f_close(f_bmp);
     
111.     }
     
112. #if BMP_USE_MALLOC == 1     /* 使用malloc */
     
113.     piclib_mem_free(databuf);
     
114.     piclib_mem_free(f_bmp);
     
115. #endif
     
116.     return res;
     
117. }

复制代码

该函数实现了对LCD屏幕的任意指定区域进行截屏保存，用到的方法就是47.1.1节我们所介绍的方法，该函数实现了将LCD任意指定区域的内容，保存个为16位BMP格式，存放在指定位置（由filename决定）。注意，代码中的BMP_USE_MALLOC是在bmp.h定义的一个宏，用于设置是否使用malloc，本章我们选择使用malloc。

2. main.c代码
main.c前面定义了一些变量和数组，具体如下：

1. /* JPEG数据接收缓冲区区域大小（最大65535字节），单位：字 */
   
2. #define JPEG_BUF_REGION_SIZE    (15918)   
   
3. #define JPEG_BUF_REGION_NUM     (DMA_NODE_NUM)    /* JPEG数据接收缓冲区区域数量 */
   
4. /* OV5640输出数据格式
   
5. * 0: RGB565格式
   
6. * 1: JPEG格式
   
7. */
   
8. static uint8_t g_ov_mode;  
   
9. 
   
10. static uint16_t g_offset_line;                         /* LCD显示起始偏移行 */
    
11. static uint8_t g_bmp_request = 0;                     /* BMP拍照请求标志 */
    
12. static uint32_t g_jpeg_data_buf[JPEG_BUF_REGION_NUM][JPEG_BUF_REGION_SIZE]
    
13. __attribute__((aligned(4)));          /* JPEG数据缓冲区 */
    
14. static uint32_t g_jpeg_data_recv_len = 0;            /* JPEG数据缓冲区中有效数据的长度 */
    
15. 
    
16. /* JPEG数据状态
    
17. * 0: 未采集完成
    
18. * 1: 采集完成
    
19. */
    
20. static uint8_t g_jpeg_data_sta = 0;

复制代码

在main.c里面，总共有7个函数，我们接下来分别介绍。首先是DCMI帧捕获完成回调函数，其定义如下：

1. /**
   
2. * @brief   DCMI帧捕获完成回调函数
   
3. * @param   hdcmi: DCMI句柄指针
   
4. * @param   node: 正在传输的DMA链表节点编号
   
5. * @retval  无
   
6. */
   
7. void dcmi_frame_transfer_complete_user_cb(DCMI_HandleTypeDef *hdcmi,
   
8. uint8_t node)
   
9. {
   
10.     UNUSED(node);
    
11.    
    
12.     LED1_TOGGLE();
    
13.     if (g_ov_mode != 0)
    
14.     {
    
15.         /* 停止DCMI捕获 */
    
16.         dcmi_stop();
    
17.         
    
18.         /* 更新采集到的JPEG数据量 */
    
19.         g_jpeg_data_recv_len += (JPEG_BUF_REGION_SIZE –
    
20. (__HAL_DMA_GET_COUNTER(hdcmi->DMA_Handle) / sizeof(uint32_t)));
    
21.         
    
22.         /* 标记JPEG数据采集完成 */
    
23.         g_jpeg_data_sta = 1;
    
24.     }
    
25.     else
    
26.     {
    
27.         /* 处理BMP拍照请求 */
    
28.         if (g_bmp_request != 0)
    
29.         {
    
30.             g_bmp_request = 0;
    
31.             dcmi_stop();
    
32.         }
    
33.         
    
34.         /* 更新LCD显示位置 */
    
35.         lcd_set_cursor(0, g_offset_line);
    
36.         lcd_write_ram_prepare();
    
37.     }
    
38. }

复制代码

该函数用于DCMI帧捕获完成相关代码，包括：LED1翻转；如果是JPEG格式，停止DCMI捕获、更新采集到的JPEG数据量、标记JPEG数据采集完成；如果是RGB565格式，更新LCD显示位置，并处理BMP拍照请求。
接下来介绍的是DMA传输完成用户回调函数，其定义如下：

1. /**
   
2. * @brief   DMA传输完成用户回调函数
   
3. * @param   node: 传输完成的DMA链表节点编号
   
4. * @retval  无
   
5. */
   
6. void dcmi_dma_transfer_complete_user_cb(uint8_t node)
   
7. {
   
8.     if (g_ov_mode != 0)
   
9.     {
   
10.         /* 更新采集到的JPEG数据量 */
    
11.         g_jpeg_data_recv_len += JPEG_BUF_REGION_SIZE;
    
12.     }
    
13. }
    
14. 该函数用于更新采集到的JPEG数据量。
    
15. 接下来介绍的是切换为OV5640模式函数，其定义如下：
    
16. /**
    
17. * @bref    切换为OV5640模式
    
18. * @param   无
    
19. * @retval  无
    
20. */
    
21. static void sw_ov5640_mode(void)
    
22. {
    
23.     GPIO_InitTypeDef gpio_init_struct;
    
24.    
    
25.     /* 开启OV5650输出 */
    
26.     ov5640_write_reg(0x3017, 0xFF);
    
27.     ov5640_write_reg(0x3018, 0xFF);
    
28.    
    
29.     /* PC8/9/11复用为DCMI功能 */
    
30.     gpio_init_struct.Pin = GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_11;
    
31.     gpio_init_struct.Mode = GPIO_MODE_AF_PP;
    
32.     gpio_init_struct.Pull = GPIO_PULLUP;
    
33.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
    
34.     gpio_init_struct.Alternate = GPIO_AF13_DCMI;
    
35.     HAL_GPIO_DeInit(GPIOC, GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_11);
    
36.     HAL_GPIO_Init(GPIOC, &gpio_init_struct);
    
37. }

复制代码

因为SD卡和OV5640有几个IO共用，所以这几个IO需要分时复用。该函数用于切换GPIO8/9/11的复用功能为DCMI接口，并开启OV5640，这样摄像头模块，可以开始正常工作。
接下来介绍的是切换为SD卡模式函数，其定义如下：

1. /**
   
2. * @bref    切换为SD卡模式
   
3. * @param   无
   
4. * @retval  无
   
5. */
   
6. static void sw_sdcard_mode(void)
   
7. {
   
8.     GPIO_InitTypeDef gpio_init_struct;
   
9.    
   
10.     /* 关闭OV5650输出 */
    
11.     ov5640_write_reg(0x3017, 0x00);
    
12.     ov5640_write_reg(0x3018, 0x00);
    
13.    
    
14.     /* PC8/9/11复用为SDMMC功能 */
    
15.     gpio_init_struct.Pin = GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_11;
    
16.     gpio_init_struct.Mode = GPIO_MODE_AF_PP;
    
17.     gpio_init_struct.Pull = GPIO_PULLUP;
    
18.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
    
19.     gpio_init_struct.Alternate = GPIO_AF12_SDMMC1;
    
20.     HAL_GPIO_DeInit(GPIOC, GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_11);
    
21.     HAL_GPIO_Init(GPIOC, &gpio_init_struct);
    
22. }

复制代码

该数用于切换GPIO8/9/11的复用功能为SDMMC接口，并关闭OV5640，这样，SD卡可以开始正常工作。
接下来介绍的是生成新照片文件名函数，其定义如下：

1. /**
   
2. * @bref    生成新照片文件名
   
3. * @param   fname: 文件名
   
4. * @param   mode: 照片格式
   
5. * @arg     0: BMP
   
6. * @arg     1: JPG
   
7. * @retval  无
   
8. */
   
9. static void camera_new_pathname(char *fname, uint8_t mode)
   
10. {
    
11.     FIL *f = NULL;
    
12.     uint16_t index = 0;
    
13.     FRESULT res;
    
14.    
    
15.     /* 申请内存 */
    
16.     f = (FIL *)mymalloc(SRAMIN, sizeof(FIL));
    
17.     if (f == NULL)
    
18.     {
    
19.         return;
    
20.     }
    
21.    
    
22.     while (index < UINT16_MAX)
    
23.     {
    
24.         if (mode == 0)
    
25.         {
    
26.             sprintf(fname, "0:PHOTO/PIC%05d.bmp", index);
    
27.         }
    
28.         else
    
29.         {
    
30.             sprintf(fname, "0:PHOTO/PIC%05d.jpg", index);
    
31.         }
    
32.         
    
33.         /* 尝试打开文件 */
    
34.         res = f_open(f, fname, FA_READ);
    
35.         if (res == FR_NO_FILE)
    
36.         {
    
37.             /* 文件不存在，则文件名为新照片文件名 */
    
38.             break;
    
39.         }
    
40.         
    
41.         index++;
    
42.     }
    
43.    
    
44.     /* 释放内存 */
    
45.     myfree(SRAMIN, f);
    
46. }

复制代码

该函数用于生成新的带路径的文件名，且不会重复，防止文件互相覆盖。该函数可以生成.bmp/.jpg的文件名，方便拍照的时候，保存到SD卡里面。
接下来介绍的是OV5640拍照jpg图片函数，其定义如下：

1. /**
   
2. * @bref    保存JPEG图片
   
3. * @param   fname: 文件名
   
4. * @retval  保存结果
   
5. * @arg     0: 成功
   
6. * @arg     其他: 失败
   
7. */
   
8. static uint8_t camera_jpeg_photo(char *fname)
   
9. {
   
10.     FIL *f = NULL;
    
11.     uint32_t memaddr[JPEG_BUF_REGION_NUM];
    
12.     uint32_t i;
    
13.     uint8_t *pbuf;
    
14.     uint32_t jpeg_start_index;
    
15.     uint32_t jpeg_data_len = 0;
    
16.     uint8_t res;
    
17.     uint32_t bw;
    
18.    
    
19.     /* 申请内存 */
    
20.     f = (FIL *)mymalloc(SRAMIN, sizeof(FIL));
    
21.     if (f == NULL)
    
22.     {
    
23.         return 0xFF;
    
24.     }
    
25.    
    
26.     g_jpeg_data_sta = 0;
    
27.     g_jpeg_data_recv_len = 0;
    
28.    
    
29.     /* 配置OV5640输出JPEG */
    
30.     g_ov_mode = 1;
    
31.     sw_ov5640_mode();
    
32.     ov5640_jpeg_mode();
    
33.     ov5640_outsize_set(4, 0, 1440, 900);
    
34.    
    
35.     /* 采集两帧JPEG数据 */
    
36.     for (i=0; i<(sizeof(memaddr) / sizeof(memaddr[0])); i++)
    
37.     {
    
38.         memaddr[i] = (uint32_t)g_jpeg_data_buf[i];
    
39.     }
    
40. dcmi_dma_init(memaddr, JPEG_BUF_REGION_SIZE, sizeof(memaddr)
    
41. / sizeof(memaddr[0]), DMA_DEST_DATAWIDTH_WORD, DMA_DINC_INCREMENTED);
    
42.     dcmi_start();
    
43.     while (g_jpeg_data_sta == 0);
    
44.     g_jpeg_data_sta = 0;
    
45.     g_jpeg_data_recv_len = 0;
    
46. dcmi_dma_init(memaddr, JPEG_BUF_REGION_SIZE, sizeof(memaddr)
    
47. / sizeof(memaddr[0]), DMA_DEST_DATAWIDTH_WORD, DMA_DINC_INCREMENTED);
    
48.     dcmi_start();
    
49.     while (g_jpeg_data_sta == 0);
    
50.    
    
51.     if (g_jpeg_data_recv_len <= (JPEG_BUF_REGION_NUM * JPEG_BUF_REGION_SIZE))
    
52.     {
    
53.         /* 寻找JPEG数据的开头（0xFF 0xD8）和结尾（0xFF 0xD9） */
    
54.         pbuf = (uint8_t *)g_jpeg_data_buf;
    
55.         jpeg_start_index = JPEG_BUF_REGION_NUM
    
56. * JPEG_BUF_REGION_SIZE * sizeof(uint32_t);
    
57.         for (i=1; i<(g_jpeg_data_recv_len * sizeof(uint32_t)); i++)
    
58.         {
    
59.             if (jpeg_start_index == JPEG_BUF_REGION_NUM  
    
60. * JPEG_BUF_REGION_SIZE * sizeof(uint32_t))
    
61.             {
    
62.                 if ((pbuf[i - 1] == 0xFF) && (pbuf[i] == 0xD8))
    
63.                 {
    
64.                     jpeg_start_index = i - 1;
    
65.                 }
    
66.             }
    
67.             else
    
68.             {
    
69.                 if ((pbuf[i - 1] == 0xFF) && (pbuf[i] == 0xD9))
    
70.                 {
    
71.                     jpeg_data_len = i - 1 - jpeg_start_index + 2;
    
72.                     break;
    
73.                 }
    
74.             }
    
75.         }
    
76.     }
    
77.    
    
78.     /* 将有效的JPEG数据写入文件 */
    
79.     if (jpeg_data_len != 0)
    
80.     {
    
81.         sw_sdcard_mode();
    
82.         res = f_open(f, fname, FA_WRITE | FA_CREATE_NEW);
    
83.         if (res == FR_OK)
    
84.         {
    
85.             res = f_write(f, &pbuf[jpeg_start_index], jpeg_data_len, &bw);
    
86.             f_close(f);
    
87.         }
    
88.     }
    
89.     else
    
90.     {
    
91.         res = 0xFD;
    
92.     }
    
93.    
    
94.     /* 配置OV5640输出RGB565 */
    
95.     g_ov_mode = 0;
    
96.     sw_ov5640_mode();
    
97.     ov5640_rgb565_mode();
    
98.    
    
99.     /* 配置DCMI */
    
100.     memaddr[0] = (uint32_t)&LCD->LCD_RAM;
     
101. dcmi_dma_init(memaddr, UINT16_MAX, 1, DMA_DEST_DATAWIDTH_HALFWORD,
     
102. DMA_DINC_FIXED);
     
103.    
     
104.     myfree(SRAMIN, f);
     
105.    
     
106.     return res;
     
107. }

复制代码

该函数实现OV5640的JPEG图像采集，并保存图像到SD卡，完成JPEG拍照。该函数首先设置OV5640工作在JPEG模式，然后，设置输出分辨率为WXGA+（1440*900）。然后，开始采集JPEG数据，将第二帧JPEG数据，保留下来，并写入SD卡里面，完成一次JPEG拍照。这里，我们丢弃第一帧JPEG数据，是防止采集到的图像数据不完整，导致图片错误。
另外，在保存jpeg图片的时候，我们将0XFF，0XD8和0XFF，0XD9之外的数据，进行了剔除，只留下0XFF，0XD8~0XFF，0XD9之间的数据，保证图片文件最小，且无其他乱的数据。
注意，在保存图片的时候，必须将PC8/9/11切换为SD卡模式，并关闭OV5640的输出。在图片保存完成以后，切换回OV5640模式，并重新使能OV5640的输出。
最后介绍的是main函数，其定义如下：

1. int main(void)
   
2. {
   
3.     uint8_t res;
   
4.     uint8_t sd_ok = 1;
   
5.     char *fname = NULL;
   
6.     uint16_t output_height;
   
7.     uint8_t scale = 1;
   
8.     float fac;
   
9.     uint32_t memaddr;
   
10.     uint8_t t = 0;
    
11.     uint8_t key;
    
12. 
    
13.     HAL_Init();                                 /* HAL库初始化 */
    
14.     HAL_ICACHE_Enable();                        /* 使能指令缓存 */
    
15.     sys_stm32_clock_init(250, 4, 2, 2);        /* 配置时钟，250MHz */
    
16.     delay_init(250);                            /* 初始化延时 */
    
17.     usart_init(115200);                         /* 初始化串口 */
    
18.     led_init();                                 /* 初始化LED */
    
19.     beep_init();                                /* 初始化蜂鸣器 */
    
20.     key_init();                                 /* 初始化按键 */
    
21.     lcd_init();                                 /* 初始化LCD */
    
22.     my_mem_init(SRAMIN);                        /* 初始化内部内存池 */
    
23.     ov5640_init();                              /* 初始化OV5640 */
    
24.     sw_sdcard_mode();                           /* 切换为SD卡模式 */
    
25.     exfuns_init();                              /* 为exfuns申请内存 */
    
26.     f_mount(fs[0], "0:", 1);                    /* 挂载SD卡 */
    
27.     f_mount(fs[1], "1:", 1);                    /* 挂载NOR Flash */
    
28.     piclib_init();                              /* 初始化画图 */
    
29.    
    
30.     /* 检查字库 */
    
31.     while (fonts_init() != 0)
    
32.     {
    
33.         lcd_show_string(30, 30, 200, 16, 16, "Font Error!  ", RED);
    
34.         delay_ms(500);
    
35.         lcd_show_string(30, 30, 200, 16, 16, "Please Check!", RED);
    
36.         delay_ms(500);
    
37.     }
    
38.     lcd_fill(30, 30, 30 + 200, 30 + 16, WHITE);
    
39.    
    
40.     text_show_string(30, 50, 200, 16, "正点原子STM32开发板",16,0, RED);
    
41.     text_show_string(30, 70, 200, 16, "照相机实验", 16, 0, RED);
    
42.     text_show_string(30, 90, 200, 16, "KEY0: 拍照(BMP格式)", 16, 0, RED);
    
43.     text_show_string(30, 110, 200, 16, "KEY1: 拍照(JPG格式)", 16, 0, RED);
    
44.     text_show_string(30, 130, 200, 16, "WK_UP: Full/Scale", 16, 0, RED);
    
45.    
    
46.     /* 创建PHOTO文件夹 */
    
47.     res = f_mkdir("0:/PHOTO");
    
48.     if ((res != FR_OK) && (res != FR_EXIST))
    
49.     {
    
50.         sd_ok = 0;
    
51.         text_show_string(30, 150, 200, 16, "SD卡错误!", 16, 0, RED);
    
52.         text_show_string(30, 170, 200, 16, "拍照功能将不可用!", 16, 0, RED);
    
53.         delay_ms(500);
    
54.     }
    
55.    
    
56.     /* 申请内存 */
    
57.     fname = (char *)mymalloc(SRAMIN, 30);
    
58.     while (fname == NULL)
    
59.     {
    
60.         text_show_string(30, 190, 200, 16, "内存分配失败!", 16, 0, RED);
    
61.         delay_ms(500);
    
62.         lcd_fill(30, 190, 30 + 200, 190 + 16, WHITE);
    
63.         delay_ms(500);
    
64.     }
    
65.    
    
66.     /* 初始化OV5640 */
    
67.     while (ov5640_init() != 0)
    
68.     {
    
69.         text_show_string(30, 190, 200, 16, "OV5640错误!", 16, 0, RED);
    
70.         delay_ms(500);
    
71.         lcd_fill(30, 190, 30 + 200, 190 + 16, WHITE);
    
72.         delay_ms(500);
    
73.     }
    
74.    
    
75.     /* 配置OV5640 */
    
76.     g_ov_mode = 0;
    
77.     ov5640_rgb565_mode();
    
78.     ov5640_focus_init();
    
79.     ov5640_light_mode(0);
    
80.     ov5640_color_saturation(3);
    
81.     ov5640_brightness(4);
    
82.     ov5640_contrast(3);
    
83.     ov5640_sharpness(33);
    
84.     ov5640_focus_constant();
    
85.     if (lcddev.height == 1024)
    
86.     {
    
87.         g_offset_line = (lcddev.height - 800) / 2;
    
88.         output_height = 800;
    
89.         ov5640_write_reg(0x3035, 0x51);
    
90.     }
    
91.     else
    
92.     {
    
93.         g_offset_line = 0;
    
94.         output_height = lcddev.height;
    
95.     }
    
96.     ov5640_outsize_set(4, 0, lcddev.width, output_height);
    
97.     fac = (float)800.f / output_height;
    
98.    
    
99.     lcd_clear(BLACK);
    
100.     lcd_set_cursor(0, g_offset_line);
     
101.     lcd_write_ram_prepare();
     
102.    
     
103.     /* 配置DCMI */
     
104.     dcmi_init();
     
105.     memaddr = (uint32_t)&LCD->LCD_RAM;
     
106. dcmi_dma_init(&memaddr, UINT16_MAX, 1, DMA_DEST_DATAWIDTH_HALFWORD,
     
107. DMA_DINC_FIXED);
     
108.     dcmi_start();
     
109.    
     
110.     while (1)
     
111.     {
     
112.         key = key_scan(0);
     
113.         if ((key == KEY0_PRES) || (key == KEY1_PRES))
     
114.         {
     
115.             if (sd_ok == 0)
     
116.             {
     
117.                 dcmi_stop();
     
118.                 text_show_string(30, 130, 200, 16, "SD卡错误!", 16, 0, RED);
     
119.                 text_show_string(30, 150, 200, 16, "拍照功能不可用!", 16, 0, RED);
     
120.             }
     
121.             else
     
122.             {
     
123.                 if (key == KEY0_PRES)
     
124.                 {
     
125.                     delay_ms(300);
     
126.                     
     
127.                     /* 发起BMP拍照请求，并等待请求响应 */
     
128.                     g_bmp_request = 1;
     
129.                     while (g_bmp_request != 0);
     
130.                     
     
131.                     /* BMP拍照 */
     
132.                     sw_sdcard_mode();
     
133.                     camera_new_pathname(fname, 0);
     
134.                     res = bmp_encode((uint8_t *)fname, 0, g_offset_line,
     
135. lcddev.width, output_height, 0);
     
136.                 }
     
137.                 else if (key == KEY1_PRES)
     
138.                 {
     
139.                     /* JPEG拍照 */
     
140.                     dcmi_stop();
     
141.                     sw_sdcard_mode();
     
142.                     camera_new_pathname(fname, 1);
     
143.                     res = camera_jpeg_photo(fname);
     
144.                     
     
145.                     /* 重新配置OV5640 */
     
146.                     if (lcddev.height == 1024)
     
147.                     {
     
148.                         ov5640_write_reg(0x3035, 0x51);
     
149.                     }
     
150.                     if (scale == 0)
     
151.                     {
     
152.                         ov5640_outsize_set((1280 - fac * lcddev.width) / 2, 0,
     
153. lcddev.width, output_height);
     
154.                     }
     
155.                     else
     
156.                     {
     
157.                         ov5640_outsize_set(4, 0, lcddev.width, output_height);
     
158.                     }
     
159.                 }
     
160.                
     
161.                 /* 根据拍照结果进行提示 */
     
162.                 if (res == 0)
     
163.                 {
     
164.                     text_show_string(10, 130, 240, 16, "拍照成功!", 16, 0, RED);
     
165.                     text_show_string(10, 150, 240, 16, "保存为:", 16, 0, RED);
     
166.                     text_show_string(10 + 56, 150, 240, 16, (char *)fname,
     
167. 16, 0, RED);
     
168.                     BEEP(1);
     
169.                     delay_ms(100);
     
170.                     BEEP(0);
     
171.                 }
     
172.                 else
     
173.                 {
     
174.                     text_show_string(10, 130, 240, 16, "写入文件错误!", 16, 0, RED);
     
175.                 }
     
176.                 sw_ov5640_mode();
     
177.             }
     
178.             delay_ms(1000);
     
179.             lcd_set_cursor(0, g_offset_line);
     
180.             lcd_write_ram_prepare();
     
181.             dcmi_start();
     
182.         }
     
183.         else if (key == WKUP_PRES)
     
184.         {
     
185.             /* 切换Full Size和Scale */
     
186.             scale = !scale;
     
187.             if (scale == 0)
     
188.             {
     
189.                 ov5640_outsize_set((1280 - fac * lcddev.width) / 2, 0,
     
190. lcddev.width, output_height);
     
191.             }
     
192.             else
     
193.             {
     
194.                 ov5640_outsize_set(4, 0, lcddev.width, output_height);
     
195.             }
     
196.         }
     
197.         
     
198.         if (++t == 20)
     
199.         {
     
200.             t = 0;
     
201.             LED0_TOGGLE();
     
202.         }
     
203.         
     
204.         delay_ms(10);
     
205.     }
     
206. }

复制代码

该函数完成对各相关硬件的初始化，然后检测OV5640，初始化OV5640位RGB565模式，显示采集到的图像到LCD上面，实现对图像进行预览。进入主循环以后，按KEY0按键，可以实现BMP拍照（实际上就是截屏，通过bmp_encode函数实现）；按KEY1按键，可实现JPEG拍照（1440*900分辨率，通过ov5640_jpg_photo函数实现）；按KEY_UP按键，可以实现图像缩放/不缩放预览。

47.4 下载验证
将程序下载到开发板后，可以看到LCD首先显示一些实验相关的信息，如图47.4.1所示：

图47.4.1显示实验相关信息

显示了上图的信息后，自动进入监控界面。可以看到LED0不停的闪烁，提示程序已经在运行了。此外，LED1不停闪烁，提示进入DCMI中断回调服务函数，进行jpeg数据处理。此时，我们可以按下KEY0和KEY1，即可进行bmp/jpg拍照。拍照得到的照片效果如图47.4.2和图47.4.3所示：

图47.4.2 拍照样图（bmp拍照样图）

图47.4.3 拍照样图（jpg拍照样图）

按KEY_UP可以实现缩放/不缩放显示。