本文章将会介绍一种通过串口显示模组显示摄像头图片的方法。文章中所介绍的方法和代码仅供个人开发者测试使用，无法保证商用的稳定性。

项目的主要功能可以列为以下几个：

1、 显示屏实时显示摄像头采集到的图片

2、 可以点击按钮拍摄一张图片并且保存到TF卡中

3、 切换彩色和灰度

4、 可以切换分辨率（240*320、240*240、160*160、80*80）

5、 可以切换到浏览图片的模式

6、 可以浏览上一张图片

7、 可以浏览下一张图片

在进行这个项目之前我们先来了解一下需要用到哪些硬件模块。

1、 STONE 7英寸800*480分辨率的串口显示模组

2、 STM32F103ZE开发板

3、 OV7670摄像头模组

4、 少量相关线材

我们可以先看看相关硬件模组的图片：

STONE TFT LCD Module

STM32F103ZE开发板

这个开发板有很多集成的功能：

1、 使用Cotex-M3核芯片，STM32F103ZET6,

2、 144P引脚

3、 外部晶振8M，时钟晶振32768Hz

4、 标准20P 插座，JTAG接口，用于Jlink、Ulink、ST-Link等下载调试程序

5、 标准4P插针，SWD接口，使用2线通信方式调试下载程序

6、 所有I/O口引出插针，方便扩展实验

7、 USB-TTL串口转换电路，实现USB接口串口通讯

8、 自动下载适配电路，使用串口下载无需频繁切换，一键下载

9、 MAX232转换电路，适用于外接串口线

10、 一体化红外接收头，用户红外遥控接收功能

11、 DS18B20插座，直接插入芯片即可实现数字测温功能

12、 带时钟后备电池，保持时钟及重要信息掉电不丢失

13、 EEPROM芯片24c02，存储常用用户信息，使用IIC通讯

14、 FLASH芯片W25Q64,8M存储器，可以存储图片、系统数据等多种信息

15、 SPI模式SD卡座，使用TF卡，使用PI通讯

16、 SDIO模式SD卡座，使用TF卡，专用的SDIO接口，高速，稳定。

17、 RF24L01插座，用于测试无线通讯（至少需2台机器配套使用）

18、 3路普通按键输入功能，人机接口

19、 1路唤醒按键，用于从低功耗或者待机模式唤醒

20、 2路用户LED灯，做基本的状态、运行指示

21、 1路USB设备接口，用于调试USB设备功能，如读卡器、usb转串口功能

22、 TFT彩屏液晶接口，包含触摸屏接口，直接插入配套屏幕可使用

23、 摄像头预留接口，配套摄像头模块实现视频演示功能

24、 1路蜂鸣器

25、 1路触摸按键功能

26、 自带自恢复保险丝，保护电脑不受损坏

27、 复位按键

28、 电源指示灯

29、 BOOT启动选择插针

30、 VREF参考电压选择插针

31、 CAN，USB切换插针

32、 3.3V外扩电源插针

33、 5V外扩电源插针

但是实际上，我们只用到了他的摄像头接口和串口。

STONE TFT-LCD显示模组

STONE STVC070WT-01是一款7英寸，分辨率为800*480的显示模组。这个显示模组可以在STONE官网购买，也可以在STONE的网上购物平台链接购买。

STONE STVC070WT-01的通讯方式为UART-RS232和UART-TTL。本项目我使用的是UART-TTL通讯方式。

显示模组的开发方式很简单，MCU只需要通过UART发送指令到STONE显示模组控制显示的内容就可以了，同样的原理，当用户触碰STONE显示屏时，显示模组也通过UART把相关的指令发送到MCU，然后MCU再去控制相应的设备（如电机转动，灯的开关等等）。

7 inches STONE STVC070WT-01

厂家提供的物料如下：

主要包装清单：

1、 转接线和转接口

2、 USB-TTL转接板

3、 U盘（内含开发资料）

4、 Micro USB线

5、 USB转换板

6、 STONE STVC070WT-01显示模组

7、 12V电源适配器

STONE显示模组简介

STVC070WT-01是TFT显示器和触摸控制器。它包括处理器，控制程序，驱动程序，闪存，RS232/RS485/TTL端口，触摸屏、电源等，是一个功能强大的显示系统

操作系统简单，可由任意单片机控制。STVC070WT-01可用于执行所有基本功能，如文本显示、图像显示、曲线显示、触摸功能、视音频功能等。

-内置Cortex CPU和驱动

-可用任何单片机来控制

-显示图片/文字/曲线

- 65536彩色TFT显示

-可以触摸操作

- RS232/ RS485/ TTL UART接口和USB端口

-宽电压范围

STVC070WT-01显示模组的控制原理

TFT-LCD模块通过命令与MCU通信(十六进制)，然后MCU将会按照接收到的命令工作。

3个步骤就可以完成STONE显示模组的固件开发

使用STONE的TFT-LCD模块只需3个步骤:

1.设计一组人机图片（UI）。

2.UART-TTL直接连接客户的MCU。

3.编写一个简单的程序，由单片机通过命令控制TFT-LCD模块。(十六进制代码)。

TFT液晶模块串口命令帧由5个数据块组成，所有的串口命令或数据都用十六进制格式表示。数据传输在MSB的方式。例如，对于0x1234，首先发送0x12，然后发送0x34。

STONE TFT-LCD显示模组的应用场景




STONE显示模组广泛应用于各种工业领域，如：

1、 医疗美容设备

2、 工程机械及车辆设备

3、 电子仪器

4、 工业控制系统

5、 电力行业

6、 民用电子设备

7、 自动化设备

8、 交通。

UI图片设计

用戶通过使用Photoshop或者其他软件设计UI界面

我设计的界面如下：

第一张图片是主界面图片，第二章图片是按钮按下时的效果。

利用TOOL2019软件设生成LCD模组配置文件

点击箭头所指的按钮就可以生成配置文件，然后把配置文件下载到显示模组中就可以显示出我们设计的UI界面了。

这部分的内容和教程我就不详细介绍了，大家可以到STONE官网去下载到很详细的教程。

另外还需要设计一张相同的图片作为按钮按下时的效果，只需要把按钮位置的颜色改表以下即可。

接线和焊接

前面的内容我介绍了STONE STVC070WT-01的相关开发操作，后面的内容我将会重点介绍STM32 MCU和VO7670摄像头。在此之前，我们先了解一下整个项目的硬件部分如何连接。

STONE触摸显示项目完整的接线示意图

OV7670模块 ---------- STM32开发板：

OV_D0~D7  -----------   PC0~7

OV_SCL    ------------  PD3

OV_SDA    ------------  PG13

OV_VSYNC  ------------  PA8

FIFO_RRST -----------   PG14

FIFO_OE   -----------   PG15

FIFO_WRST ------------  PD6

FIFO_WEN  ------------  PB3

FIFO_RCLK ------------  PB4

电源适配器是12V的，它需要给STONE STVC070WT-01显示模组供电同时通过DC-DC降压器把电压降到5伏给MCU模组和OV7670供电。

项目用到的配件

主要配件有：

1、 STM32F103ZE开发板

2、 DC-DC降压模组

3、 UART转接线

由于STONE STVC070WT-01的通讯方式默认是UART-TTL，所以转接线我们就不需要RS232的接口了，把RS232的接口去掉：

焊接

把这些配件焊接在一起，效果如下：

这部分准备就绪以后就可以编写MCU的程序了。

OV7670摄像头

OV7670是一个种图象传感器，操作温度是30℃-70℃，模拟电压是2.5-3.0V，感光阵列是640*480，功耗是工作时60mW/15fps；休眠时小于20uA。

体积小，工作电压低，提供单片VGA摄像头和影像处理器的所有功能。通过SCCB总线控制，可以输入整帧、子采样、取窗口等方式的各种分辨率8位影像数据。该产品VGA图像最高达到30帧/秒。用户可以完全控制图像质量、数据格式和传输方式。所有图像处理功能过程包括伽玛曲线、白平衡、饱和度、色度等都可以通过SCCB接口编程。通过减少或消除光学或电子缺陷如固定图案噪声、托尾、浮散等，提高图像质量，得到清晰的稳定的彩色图像。

OV7670 是 OV（OmniVision）公司生产的一颗 1/6 寸的 CMOS VGA 图像传感器。该传感

器体积小、工作电压低，提供单片 VGA 摄像头和影像处理器的所有功能。通过 SCCB 总线控制，可以输出整帧、子采样、取窗口等方式的各种分辨率 8 位影像数据。该产品 VGA 图像最高达到 30 帧/秒。用户可以完全控制图像质量、数据格式和传输方式。所有图像处理功能过程包括伽玛曲线、白平衡、度、色度等都可以通过 SCCB 接口编程。 OmmiVision 图像传感器应用独有的传感器技术，通过减少或消除光学或电子缺陷如固定图案噪声、托尾、浮散等，提高图像质量，得到清晰的稳定的彩色图像。

OV7670 的特点有：

l 高灵敏度、低电压适合嵌入式应用

l 标准的 SCCB 接口，兼容 IIC 接口

l 支持 RawRGB、 RGB(GBR4:2:2， RGB565/RGB555/RGB444)， YUV(4:2:2)和 YCbCr

l 支持 VGA、 CIF，和从 CIF 到 40*30 的各种尺寸输出

l 支持自动曝光控制、自动增益控制、自动白平衡、自动消除灯光条纹

l 自动黑电平校准等自动控制功能。同时支持色饱和度、色相、伽马、锐度等设置。

l 支持闪光灯

l 支持图像缩放

OV7670 的功能框图：

OV7670 传感器包括如下一些功能模块。

1. 感光整列（Image Array）

OV7670 总共有 656*488 个像素，其中 640*480 个有效（即有效像素为 30W）。

2. 时序发生器（Video Timing Generator）

时序发生器具有的功能包括：整列控制和帧率发生（7 种不同格式输出）、内部信号发生器535和分布、帧率时序、自动曝光控制、输出外部时序（VSYNC、 HREF/HSYNC 和 PCLK）。

3. 模拟信号处理（Analog Processing）

模拟信号处理所有模拟功能，并包括：自动增益（AGC）和自动白平衡（AWB）。

4. A/D 转换（A/D）

原始的信号经过模拟处理器模块之后 ，分 G 和 BR 两路进入一个 10 位的 A/D 转换器，

A/D 转换器工作在 12M 频率，与像素频率完全同步（转换的频率和帧率有关）。

A/D 范围乘积和 A/D 的范围控制共同设置 A/D 的范围和最大值，允许用户根据应用调整图片的亮度。

接下来我们介绍一下 OV7670 的图像数据输出格式。首先我们简单介绍几个定义：

VGA，即分辨率为 640*480 的输出模式；

QVGA，即分辨率为 320*240 的输出格式，也就是本章我们需要用到的格式；

QQVGA，即分辨率为 160*120 的输出格式；

PCLK，即像素时钟，一个 PCLK 时钟，输出一个像素(或半个像素)。

VSYNC，即帧同步信号。HREF /HSYNC，即行同步信号。

OV7670 的图像数据输出（通过 D[7:0]）就是在 PCLK， VSYNC 和 HREF/ HSYNC 的控制下进行的。

首先看看行输出时序，如图所示：

从上图可以看出，图像数据在 HREF 为高的时候输出，当 HREF 变高后，每一个 PCLK 时

钟，输出一个字节数据。比如我们采用 VGA 时序， RGB565 格式输出，每 2 个字节组成一个像素的颜色（高字节在前，低字节在后），这样每行输出总共有 640*2 个 PCLK 周期，输出 640*2个字节。

再来看看帧时序（ VGA 模式）：

上图清楚的表示了 OV7670 在 VGA 模式下的数据输出，注意，图中的 HSYNC 和 HREF

其实是同一个引脚产生的信号，只是在不同场合下面，使用不同的信号方式，我们本章用到的是 HREF。

因为 OV7670 的像素时钟（ PCLK）最高可达 24Mhz，我们用 STM32F103ZET6 的 IO 口直接抓取，是非常困难的，也十分占耗 CPU（可以通过降低 PCLK 输出频率，来实现 IO 口抓取，但是不推荐）。

在本项目中，我使用了RGB565模式，拍摄到的图像数据是RGB原始数据，然后通过UART传输到STONE显示模组中。

OV7670的驱动程序

1. u8 OV7670_Init(void)
   
2. 
   
3. {
   
4. 
   
5. u8 temp;
   
6. 
   
7. u16 i=0;
   
8. 
   
9. 
   
10. 
    
11.         GPIO_InitTypeDef  GPIO_InitStructure;
    
12. 
    
13.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD|RCC_APB2Periph_GPIOG, ENABLE);         
    
14. 
    
15. 
    
16. 
    
17. 
    
18. 
    
19. GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_8;
    
20. 
    
21. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    
22. 
    
23. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
24. 
    
25.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
26. 
    
27. 
    
28. 
    
29. 
    
30. 
    
31. 
    
32.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4;
    
33. 
    
34.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
35. 
    
36.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    
37. 
    
38.         GPIO_SetBits(GPIOB,GPIO_Pin_3|GPIO_Pin_4);
    
39. 
    
40. 
    
41. 
    
42. 
    
43. 
    
44. GPIO_InitStructure.GPIO_Pin  = 0xff;
    
45. 
    
46. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    
47. 
    
48.         GPIO_Init(GPIOC, &GPIO_InitStructure);
    
49. 
    
50. 
    
51. 
    
52. 
    
53. 
    
54. 
    
55. 
    
56.            GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_6;  
    
57. 
    
58. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
59. 
    
60.         GPIO_Init(GPIOD, &GPIO_InitStructure);
    
61. 
    
62. GPIO_SetBits(GPIOD,GPIO_Pin_6);
    
63. 
    
64. 
    
65. 
    
66.    
    
67. 
    
68. 
    
69. 
    
70. GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_14|GPIO_Pin_15;  
    
71. 
    
72. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
73. 
    
74.         GPIO_Init(GPIOG, &GPIO_InitStructure);
    
75. 
    
76. GPIO_SetBits(GPIOG,GPIO_Pin_14|GPIO_Pin_15);
    
77. 
    
78. 
    
79. 
    
80.     GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);        //SWD
    
81. 
    
82. 
    
83. 
    
84.         SCCB_Init();                //³õʼ»¯SCCB µÄIO¿Ú                     
    
85. 
    
86.         if(SCCB_WR_Reg(0x12,0x80))return 1;        //¸´Î»SCCB          
    
87. 
    
88. delay_ms(50);
    
89. 
    
90. temp=SCCB_RD_Reg(0x0b);   
    
91. 
    
92. if(temp!=0x73)return 2;  
    
93. 
    
94.         temp=SCCB_RD_Reg(0x0a);   
    
95. 
    
96. if(temp!=0x76)return 2;
    
97. 
    
98. //³õʼ»¯ÐòÁР         
    
99. 
    
100. for(i=0;i<sizeof(ov7670_init_reg_tbl_RGB565)/sizeof(ov7670_init_reg_tbl_RGB565[0])/2;i++)
     
101. 
     
102. {
     
103. 
     
104.            SCCB_WR_Reg(ov7670_init_reg_tbl_RGB565[i][0],ov7670_init_reg_tbl_RGB565[i][1]);
     
105. 
     
106. delay_ms(2);
     
107. 
     
108.         }
     
109. 
     
110.            return 0x00; //ok
     
111. 
     
112. }
     
113. 
     
114. 
     
115. 
     
116. OV7670_CONFIG ov7670_config;
     
117. 
     
118. 
     
119. 
     
120. //ÅäÖÃOV7670µÄÊä³ö
     
121. 
     
122. void config_ov7670_OutPut(u16 xsta,u16 ysta,u16 width,u16 height,u8 ouput_mode){
     
123. 
     
124. int i=0;
     
125. 
     
126. ov7670_config.xsta = xsta;
     
127. 
     
128. ov7670_config.ysta = ysta;
     
129. 
     
130. ov7670_config.width = width;
     
131. 
     
132. ov7670_config.height = height;
     
133. 
     
134. ov7670_config.mode = ouput_mode;
     
135. 
     
136. 
     
137.   
     
138. 
     
139. if(ouput_mode){        //²ÊÉ«Êä³ö
     
140. 
     
141. for(i=0;i<sizeof(ov7670_init_reg_tbl_YUV)/sizeof(ov7670_init_reg_tbl_YUV[0])/2;i++)
     
142. 
     
143. {
     
144. 
     
145. SCCB_WR_Reg(ov7670_init_reg_tbl_YUV[i][0],ov7670_init_reg_tbl_YUV[i][1]);
     
146. 
     
147. delay_ms(2);
     
148. 
     
149. }
     
150. 
     
151. 
     
152. 
     
153. }else{        //ºÚ°×Êä³ö
     
154. 
     
155. for(i=0;i<sizeof(ov7670_init_reg_tbl_RGB565)/sizeof(ov7670_init_reg_tbl_RGB565[0])/2;i++)
     
156. 
     
157. {
     
158. 
     
159. SCCB_WR_Reg(ov7670_init_reg_tbl_RGB565[i][0],ov7670_init_reg_tbl_RGB565[i][1]);
     
160. 
     
161. delay_ms(2);
     
162. 
     
163. }
     
164. 
     
165. }
     
166. 
     
167. OV7670_Window_Set(176,10,width,height);        //ÉèÖô°¿Ú
     
168. 
     
169. LCD_Clear(WHITE);
     
170. 
     
171. }
     
172. 
     
173. void OV7670_Light_Mode(u8 mode)
     
174. 
     
175. {
     
176. 
     
177. u8 reg13val=0XE7;
     
178. 
     
179. u8 reg01val=0;
     
180. 
     
181. u8 reg02val=0;
     
182. 
     
183. switch(mode)
     
184. 
     
185. {
     
186. 
     
187. case 1://sunny
     
188. 
     
189. reg13val=0XE5;
     
190. 
     
191. reg01val=0X5A;
     
192. 
     
193. reg02val=0X5C;
     
194. 
     
195. break;
     
196. 
     
197. case 2://cloudy
     
198. 
     
199. reg13val=0XE5;
     
200. 
     
201. reg01val=0X58;
     
202. 
     
203. reg02val=0X60;
     
204. 
     
205. break;
     
206. 
     
207. case 3://office
     
208. 
     
209. reg13val=0XE5;
     
210. 
     
211. reg01val=0X84;
     
212. 
     
213. reg02val=0X4c;
     
214. 
     
215. break;
     
216. 
     
217. case 4://home
     
218. 
     
219. reg13val=0XE5;
     
220. 
     
221. reg01val=0X96;
     
222. 
     
223. reg02val=0X40;
     
224. 
     
225. break;
     
226. 
     
227. }
     
228. 
     
229. SCCB_WR_Reg(0X13,reg13val);
     
230. 
     
231. SCCB_WR_Reg(0X01,reg01val);
     
232. 
     
233. SCCB_WR_Reg(0X02,reg02val);
     
234. 
     
235. }          
     
236. 
     
237. void OV7670_Color_Saturation(u8 sat)
     
238. 
     
239. {
     
240. 
     
241. u8 reg4f5054val=0X80;
     
242. 
     
243. u8 reg52val=0X22;u8 reg53val=0X5E;
     
244. 
     
245.         switch(sat)
     
246. 
     
247. {
     
248. 
     
249. case 0://-2
     
250. 
     
251. reg4f5054val=0X40;           
     
252. 
     
253. reg52val=0X11;
     
254. 
     
255. reg53val=0X2F;                  
     
256. 
     
257. break;
     
258. 
     
259. case 1://-1
     
260. 
     
261. reg4f5054val=0X66;            
     
262. 
     
263. reg52val=0X1B;
     
264. 
     
265. reg53val=0X4B;          
     
266. 
     
267. break;
     
268. 
     
269. case 3://1
     
270. 
     
271. reg4f5054val=0X99;          
     
272. 
     
273. reg52val=0X28;
     
274. 
     
275. reg53val=0X71;          
     
276. 
     
277. break;
     
278. 
     
279. case 4://2
     
280. 
     
281. reg4f5054val=0XC0;          
     
282. 
     
283. reg52val=0X33;
     
284. 
     
285. reg53val=0X8D;          
     
286. 
     
287. break;
     
288. 
     
289. }
     
290. 
     
291. SCCB_WR_Reg(0X4F,reg4f5054val);
     
292. 
     
293. SCCB_WR_Reg(0X50,reg4f5054val);         
     
294. 
     
295. SCCB_WR_Reg(0X51,0X00);         
     
296. 
     
297. SCCB_WR_Reg(0X52,reg52val);         
     
298. 
     
299. SCCB_WR_Reg(0X53,reg53val);         
     
300. 
     
301. SCCB_WR_Reg(0X54,reg4f5054val);         
     
302. 
     
303. SCCB_WR_Reg(0X58,0X9E);         
     
304. 
     
305. }
     
306. 
     
307. void OV7670_Brightness(u8 bright)
     
308. 
     
309. {
     
310. 
     
311. u8 reg55val=0X00;//ĬÈϾÍÊÇbright=2
     
312. 
     
313.           switch(bright)
     
314. 
     
315. {
     
316. 
     
317. case 0://-2
     
318. 
     
319. reg55val=0XB0;                  
     
320. 
     
321. break;
     
322. 
     
323. case 1://-1
     
324. 
     
325. reg55val=0X98;                  
     
326. 
     
327. break;
     
328. 
     
329. case 3://1
     
330. 
     
331. reg55val=0X18;                  
     
332. 
     
333. break;
     
334. 
     
335. case 4://2
     
336. 
     
337. reg55val=0X30;                  
     
338. 
     
339. break;
     
340. 
     
341. }
     
342. 
     
343. SCCB_WR_Reg(0X55,reg55val);
     
344. 
     
345. }
     
346. 
     
347. void OV7670_Contrast(u8 contrast)
     
348. 
     
349. {
     
350. 
     
351. u8 reg56val=0X40;
     
352. 
     
353.           switch(contrast)
     
354. 
     
355. {
     
356. 
     
357. case 0://-2
     
358. 
     
359. reg56val=0X30;                  
     
360. 
     
361. break;
     
362. 
     
363. case 1://-1
     
364. 
     
365. reg56val=0X38;                  
     
366. 
     
367. break;
     
368. 
     
369. case 3://1
     
370. 
     
371. reg56val=0X50;                  
     
372. 
     
373. break;
     
374. 
     
375. case 4://2
     
376. 
     
377. reg56val=0X60;                  
     
378. 
     
379. break;
     
380. 
     
381. }
     
382. 
     
383. SCCB_WR_Reg(0X56,reg56val);         
     
384. 
     
385. }  
     
386. 
     
387. void OV7670_Special_Effects(u8 eft)
     
388. 
     
389. {
     
390. 
     
391. u8 reg3aval=0X04;//ĬÈÏΪÆÕͨģʽ
     
392. 
     
393. u8 reg67val=0XC0;
     
394. 
     
395. u8 reg68val=0X80;
     
396. 
     
397. switch(eft)
     
398. 
     
399. {
     
400. 
     
401. case 1:
     
402. 
     
403. reg3aval=0X24;
     
404. 
     
405. reg67val=0X80;
     
406. 
     
407. reg68val=0X80;
     
408. 
     
409. break;
     
410. 
     
411. case 2:
     
412. 
     
413. reg3aval=0X14;
     
414. 
     
415. reg67val=0X80;
     
416. 
     
417. reg68val=0X80;
     
418. 
     
419. break;
     
420. 
     
421. case 3:
     
422. 
     
423. reg3aval=0X14;
     
424. 
     
425. reg67val=0Xc0;
     
426. 
     
427. reg68val=0X80;
     
428. 
     
429. break;
     
430. 
     
431. case 4:
     
432. 
     
433. reg3aval=0X14;
     
434. 
     
435. reg67val=0X40;
     
436. 
     
437. reg68val=0X40;
     
438. 
     
439. break;
     
440. 
     
441. case 5:
     
442. 
     
443. reg3aval=0X14;
     
444. 
     
445. reg67val=0X80;
     
446. 
     
447. reg68val=0XC0;
     
448. 
     
449. break;
     
450. 
     
451. case 6:
     
452. 
     
453. reg3aval=0X14;
     
454. 
     
455. reg67val=0XA0;
     
456. 
     
457. reg68val=0X40;
     
458. 
     
459. break;         
     
460. 
     
461. }
     
462. 
     
463. SCCB_WR_Reg(0X3A,reg3aval);
     
464. 
     
465. SCCB_WR_Reg(0X68,reg67val);
     
466. 
     
467. SCCB_WR_Reg(0X67,reg68val);
     
468. 
     
469. }
     
470. 
     
471. void OV7670_Window_Set(u16 sx,u16 sy,u16 width,u16 height)
     
472. 
     
473. {
     
474. 
     
475. u16 endx;
     
476. 
     
477. u16 endy;
     
478. 
     
479. u8 temp;
     
480. 
     
481. 
     
482. 
     
483. endx=(sx+width*2)%784;        //   sx:HSTART endx:HSTOP   
     
484. 
     
485.         endy=sy+height*2;        //   sy:VSTRT endy:VSTOP
     
486. 
     
487. 
     
488. //ÉèÖÃHREF
     
489. 
     
490. temp=SCCB_RD_Reg(0X32);
     
491. 
     
492. temp&=0XC0;
     
493. 
     
494. temp|=((endx&0X07)<<3)|(sx&0X07);
     
495. 
     
496. SCCB_WR_Reg(0X032,temp);
     
497. 
     
498. SCCB_WR_Reg(0X17,sx>>3);
     
499. 
     
500. SCCB_WR_Reg(0X18,endx>>3);
     
501. 
     
502. 
     
503. 
     
504. //ÉèÖÃVREF
     
505. 
     
506. temp=SCCB_RD_Reg(0X03);
     
507. 
     
508. temp&=0XF0;
     
509. 
     
510. temp|=((endy&0X03)<<2)|(sy&0X03);
     
511. 
     
512. SCCB_WR_Reg(0X03,temp);
     
513. 
     
514. SCCB_WR_Reg(0X19,sy>>2);
     
515. 
     
516. SCCB_WR_Reg(0X1A,endy>>2);
     
517. 
     
518. }
     
519. 
     

复制代码

TF卡驱动

项目还需要用到一张TF卡来存储拍摄的图片。

由于TF卡驱动程序篇幅过长，在此就不贴出来了。

大家可自行到网络上面搜索相关的代码使用。

STM32F103ZE

网络上有很多关于这颗芯片的资料和开发文档，在此简单介绍这颗芯片。

这个是STM32F103ZE的开发板:

对于这颗芯片我就不做过多介绍了。芯片下载代码是用了J-LINK，如下图：

这是一个简易版本的J-LINK，只支持SWD方式调试和下载，不支持JTAG。但是对于STM32芯片的开发，SWD调试方式已经足够了。

下载代码到STM32芯片

确保J-LINK和STM32F103ZE的接线正确，然后在KEIL开发环境中可以识别到芯片：

点击download按钮就可以把代码下载到芯片中：

STM32控制代码

STONE显示模组的数据接收一次只能接收255字节，而一张RGB565数据的图片大小是240*320*2=153600Byte=153.6KB，所以需要进行分包发送处理。

另外由于串口通讯速率的限制，图片实时刷新的效果并不是很好。本项目串口波特率配置到921600，这也是STONE串口显示模组的最高通讯波特率。

显示屏中的按钮和文本都有对应的地址，在这个项目中，显示屏组件的地址如下：

TAKE PICTRUE BUTTON : 0X002A

COLOR&GRAY BUTTON : 0X002B

CHANGE RATION BUTTON:0X002C

PREV PICTURE BUTTON:0X002D

NEXT PICTURE BUTTON:0X002E

BROWSE BUTTON : 0X002F

Main函数代码如下：

Main函数代码如下：

1. #include "led.h"
   
2. #include "delay.h"
   
3. #include "key.h"
   
4. #include "sys.h"
   
5. #include "lcd.h"
   
6. #include "usart.h"         
   
7. #include "string.h"
   
8. #include "ov7670.h"
   
9. #include "tpad.h"
   
10. #include "timer.h"
    
11. #include "exti.h"
    
12. #include "usmart.h"
    
13. #include "dma.h"
    
14. #include "sdio_sdcard.h"   
    
15. 
    
16. extern u8 ov_sta;       
    
17. extern u8 img_dis_cnt;
    
18. extern u8 data_ready;       
    
19. extern u8 USART_RX_END;
    
20. u16 user_width=240;
    
21. u16 user_heigh=240;
    
22. #define PIC_TOTAL     20
    
23. u8 sd_select=1;
    
24. u16 color_r;
    
25. u16 color_g;
    
26. u16 color_b;
    
27. void UART1_Send_Array(u8 send_array[],u16 num)
    
28. {
    
29.         u16 i=0;  
    
30.         while(i<num)
    
31.         {
    
32.                 USART_SendData(USART1,send_array[i]);  
    
33.                 while( USART_GetFlagStatus(USART1,USART_FLAG_TC)!= SET);  
    
34.                 i++;  
    
35.         }
    
36. }
    
37. void ov7670_clock_set(u8 PLL)
    
38. {
    
39.         u8 temp=0;          
    
40.         RCC->CFGR&=0XFFFFFFFC;       
    
41.         RCC->CR&=~0x01000000;            
    
42.         RCC->CFGR&=~(0XF<<18);       
    
43.         PLL-=2;//µÖÏû2¸öµ¥Î»
    
44.         RCC->CFGR|=PLL<<18;          
    
45.         RCC->CFGR|=1<<16;                  //PLLSRC ON  
    
46.         FLASH->ACR|=0x12;          
    
47.         RCC->CR|=0x01000000;          //PLLON
    
48.         while(!(RCC->CR>>25));       
    
49.         RCC->CFGR|=0x02;       
    
50.         while(temp!=0x02)     
    
51.         {   
    
52.                 temp=RCC->CFGR>>2;
    
53.                 temp&=0x03;
    
54.         }   
    
55. }
    
56. #define SEND_BUF_SIZE   169
    
57. #define LCD_X_H         5
    
58. #define LCD_X_L         6
    
59. #define LCD_Y_H         7
    
60. #define LCD_Y_L         8
    
61. u8 lcd_send_buf[SEND_BUF_SIZE]={0xa5,0x5a,0xa6,0x85,0x00,0x00,0x00,0x00,0x00};
    
62. u8 lcd_send_buf1[512]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
    
63. u8 upda_flag=1;
    
64. u16 dis_fixel=0;
    
65. void camera_refresh()
    
66. {
    
67.         u16 i=0,j=0,k=0;
    
68.         u8 color;
    
69.         u8 cnt=9;
    
70.         u16 user_x_cnt=0,user_x_start=0,lcd_send_times=0;
    
71.        
    
72.         u16 user_width1=user_width;
    
73.         u16 user_heigh1=user_heigh;
    
74.        
    
75.         if(user_width1==240)
    
76.         {
    
77.                 user_x_cnt=2;
    
78.                 user_x_start=450;
    
79.         }
    
80.         else if(user_width1==320)
    
81.         {
    
82.                 user_x_cnt=3;
    
83.                 user_x_start=410;
    
84.         }
    
85.         else if(user_width1==160)
    
86.         {
    
87.                 user_x_cnt=1;
    
88.                 user_x_start=490;
    
89.         }
    
90.         else if(user_width1==80)
    
91.         {
    
92.                 user_x_cnt=0;
    
93.                 user_x_start=530;
    
94.         }
    
95.        
    
96.         if(ov_sta==2)
    
97.         {
    
98.                 OV7670_RRST=0;         
    
99.                 OV7670_RCK_L;
    
100.                 OV7670_RCK_H;
     
101.                 OV7670_RCK_L;
     
102.                 OV7670_RRST=1;         
     
103.                 OV7670_RCK_H;  
     
104.                 upda_flag=0;
     
105.                
     
106.                 for(i=0;i<user_heigh1;i++)
     
107.                 {
     
108.                         k=i+150;
     
109.                        
     
110.                         lcd_send_buf[LCD_Y_L] = (u8)(k & 0x00ff);
     
111.                         lcd_send_buf[LCD_Y_H] = (u8)(k >> 8);                
     
112.                         cnt=9;
     
113.                         lcd_send_times=0;
     
114.                         for(j=0;j<user_width1*2;j++)
     
115.                         {
     
116.                                 OV7670_RCK_L;
     
117.                                 color=(u8)GPIOC->IDR&0XFF;
     
118.                                 OV7670_RCK_H;
     
119.                                 lcd_send_buf[cnt++]=color;
     
120.                                 if(cnt > 168)
     
121.                                 {
     
122.                                   if(lcd_send_times==0)
     
123.                                         {
     
124.                                                 dis_fixel=user_x_start;
     
125.                                                 lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
     
126.                                                 lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
     
127.                                         }
     
128.                                         else if(lcd_send_times==1)
     
129.                                         {
     
130.                                                 dis_fixel+=80;
     
131.                                                 lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
     
132.                                                 lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
     
133.                                         }
     
134.                                         else if(lcd_send_times==2)
     
135.                                         {
     
136.                                                 dis_fixel+=80;
     
137.                                                 lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
     
138.                                                 lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
     
139.                                         }
     
140.                                         else if(lcd_send_times==3)
     
141.                                         {
     
142.                                                 dis_fixel+=80;
     
143.                                                 lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
     
144.                                                 lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
     
145.                                         }
     
146.                                         if(USART_RX_END==1)
     
147.                                         {
     
148.                                                 EXTI_ClearITPendingBit(EXTI_Line8);  
     
149.                                                 ov_sta=0;       
     
150.                                                 upda_flag=1;
     
151.                                                 return;
     
152.                                         }
     
153.                                         else
     
154.                                         {
     
155.                                                 UART1_Send_Array(lcd_send_buf,169);
     
156.                                         }
     
157.                                         lcd_send_times++;
     
158.                                         if(lcd_send_times>user_x_cnt)
     
159.                                                 lcd_send_times=0;
     
160.                                         cnt=9;
     
161.                                 }
     
162.                         }
     
163.                 }
     
164.                 EXTI_ClearITPendingBit(EXTI_Line8);  
     
165.                 ov_sta=0;       
     
166.                 upda_flag=1;
     
167.         }
     
168. }       
     
169. 
     
170. void clear_display()
     
171. {
     
172.         u16 i=0,j=0,k=0;
     
173.         u8 cnt=9,lcd_send_times=0;
     
174.   u8 color;       
     
175.         u16 user_x_cnt=0,user_x_start=0;
     
176.         u16 user_width1=user_width;
     
177.         u16 user_heigh1=user_heigh;
     
178.         if(user_width1==240)
     
179.         {
     
180.                 user_x_cnt=2;
     
181.                 user_x_start=450;
     
182.         }
     
183.         else if(user_width1==320)
     
184.         {
     
185.                 user_x_cnt=3;
     
186.                 user_x_start=410;
     
187.         }
     
188.         else if(user_width1==160)
     
189.         {
     
190.                 user_x_cnt=1;
     
191.                 user_x_start=490;
     
192.         }
     
193.         else if(user_width1==80)
     
194.         {
     
195.                 user_x_cnt=0;
     
196.                 user_x_start=530;
     
197.         }
     
198.                 upda_flag=0;
     
199.                 for(i=0;i<user_heigh1;i++)
     
200.                 {
     
201.                         k=i+150;
     
202.                         lcd_send_buf[LCD_Y_L] = (u8)(k & 0x00ff);
     
203.                         lcd_send_buf[LCD_Y_H] = (u8)(k >> 8);                
     
204.                         cnt=9;
     
205.                         lcd_send_times=0;
     
206.                         for(j=0;j<user_width1*2;j++)
     
207.                         {
     
208.                                 OV7670_RCK_L;
     
209.                                 color=(u8)GPIOC->IDR&0XFF;
     
210.                                 OV7670_RCK_H;
     
211.                                 lcd_send_buf[cnt++]=0xff;
     
212.                                 if(cnt > 168)
     
213.                                 {
     
214.                                   if(lcd_send_times==0)
     
215.                                         {
     
216.                                                 dis_fixel=user_x_start;
     
217.                                                 lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
     
218.                                                 lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
     
219.                                         }
     
220.                                         else if(lcd_send_times==1)
     
221.                                         {
     
222.                                                 dis_fixel+=80;
     
223.                                                 lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
     
224.                                                 lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
     
225.                                         }
     
226.                                         else if(lcd_send_times==2)
     
227.                                         {
     
228.                                                 dis_fixel+=80;
     
229.                                                 lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
     
230.                                                 lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
     
231.                                         }
     
232.                                         else if(lcd_send_times==3)
     
233.                                         {
     
234.                                                 dis_fixel+=80;
     
235.                                                 lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
     
236.                                                 lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
     
237.                                         }
     
238.                                         UART1_Send_Array(lcd_send_buf,169);
     
239.                                         lcd_send_times++;
     
240.                                         if(lcd_send_times>user_x_cnt)
     
241.                                                 lcd_send_times=0;
     
242.                                         cnt=9;
     
243.                                 }
     
244.                         }
     
245.                 }
     
246.                 EXTI_ClearITPendingBit(EXTI_Line8);  
     
247.                 ov_sta=0;
     
248.                 upda_flag=1;       
     
249. }
     
250. 
     
251. void user_save_image()
     
252. {
     
253.         u16 i=0,j=0,k=0;
     
254.         u8 color;
     
255.         u8 cnt=9,m_cnt=0;
     
256.         u16 user_x_cnt=0,user_x_start=0,lcd_send_times=0;
     
257.         u16 user_width1=user_width;
     
258.         if(user_width1==240)
     
259.         {
     
260.                 user_x_cnt=2;
     
261.                 user_x_start=450;
     
262.         }
     
263.         else
     
264.         {
     
265.                 return;
     
266.         }
     
267.         while(ov_sta!=2);
     
268.         if(ov_sta==2)
     
269.         {
     
270.                 OV7670_RRST=0;         
     
271.                 OV7670_RCK_L;
     
272.                 OV7670_RCK_H;
     
273.                 OV7670_RCK_L;
     
274.                 OV7670_RRST=1;
     
275.                 OV7670_RCK_H;  
     
276.                 upda_flag=0;
     
277.                
     
278.                 for(i=0;i<240;i++)
     
279.                 {
     
280.                         k=i+150;
     
281.                         lcd_send_buf[LCD_Y_L] = (u8)(k & 0x00ff);
     
282.                         lcd_send_buf[LCD_Y_H] = (u8)(k >> 8);                
     
283.                         cnt=9;
     
284.                         lcd_send_times=0;
     
285.                         for(j=0;j<240*2;j++)
     
286.                         {
     
287.                                 OV7670_RCK_L;
     
288.                                 color=(u8)GPIOC->IDR&0XFF;
     
289.                                 OV7670_RCK_H;
     
290.                                 lcd_send_buf[cnt++]=color;
     
291.                                 if(cnt > 168)
     
292.                                 {
     
293.                                         m_cnt=0;
     
294.                                   if(lcd_send_times==0)
     
295.                                         {
     
296.                                                 dis_fixel=user_x_start;
     
297.                                                 lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
     
298.                                                 lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
     
299.                                                
     
300.                                                 for(m_cnt=0;m_cnt<169;m_cnt++)
     
301.                                                 {
     
302.                                                                 lcd_send_buf1[m_cnt]=lcd_send_buf[m_cnt];
     
303.                                                 }
     
304.                                         }
     
305.                                         else if(lcd_send_times==1)
     
306.                                         {
     
307.                                                 dis_fixel+=80;
     
308.                                                 lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
     
309.                                                 lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
     
310.                                                 for(m_cnt=0;m_cnt<169;m_cnt++)
     
311.                                                 {
     
312.                                                                 lcd_send_buf1[m_cnt+169]=lcd_send_buf[m_cnt];
     
313.                                                 }
     
314.                                         }
     
315.                                         else if(lcd_send_times==2)
     
316.                                         {
     
317.                                                 dis_fixel+=80;
     
318.                                                 lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
     
319.                                                 lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
     
320.                                                 for(m_cnt=0;m_cnt<169;m_cnt++)
     
321.                                                 {
     
322.                                                                 lcd_send_buf1[m_cnt+169*2]=lcd_send_buf[m_cnt];
     
323.                                                 }
     
324.                                         }
     
325.                                         UART1_Send_Array(lcd_send_buf,169);
     
326.                                         lcd_send_times++;
     
327.                                         if(lcd_send_times>user_x_cnt)
     
328.                                         {
     
329.                                                 SD_WriteDisk(lcd_send_buf1,i+240*sd_select,1);
     
330.                                                 lcd_send_times=0;
     
331.                                         }
     
332.                                         cnt=9;
     
333.                                 }
     
334.                         }
     
335.                 }
     
336.         }
     
337.                 EXTI_ClearITPendingBit(EXTI_Line8);  
     
338.                 ov_sta=0;
     
339.                 upda_flag=1;
     
340. }
     
341. 
     
342. void read_image()
     
343. {
     
344.         u8 i=0;
     
345.                 for(i=0;i<240;i++)
     
346.                 {
     
347.                                         if(SD_ReadDisk(lcd_send_buf1,i+240*sd_select,1)==0)
     
348.                                         {
     
349.                                                 UART1_Send_Array(lcd_send_buf1,507);
     
350.                                         }
     
351.                 }
     
352. }
     
353. 
     
354. int main(void)
     
355. {
     
356.         u8 pixel_ch_flag=0,user_effect_flag=0;
     
357.         delay_init();             
     
358.         NVIC_Configuration();        
     
359.         uart_init(921600);         
     
360.         LED_Init();       
     
361.         LCD_Init();       
     
362.         delay_ms(1000);
     
363.         delay_ms(1000);
     
364.                              
     
365.         while(OV7670_Init())//³õʼ»¯OV7670
     
366.         {
     
367.                 delay_ms(200);
     
368.         }
     
369.         while(SD_Init())
     
370.         {
     
371.                 delay_ms(500);
     
372.                 LED0=!LED0;
     
373.         }
     
374. 
     
375. 
     

复制代码