• （40）STM32——OV2640摄像头实验

    目录

    学习目标

    运行结果

    内容

    OV2640

    特点

    时序

    帧输出时序

    配置

    DCMI

    特点

    信号

    DMA

    寄存器

    配置

    硬件连接

    代码

    总结 

    学习目标

            今天我们要学习的是OV2640摄像头实验，采用的是DCMI接口，进行传输。个人觉得难度较大，加上没有相应的串口线，导致部分实验无法进行，所以就先讲解理论知识，等串口线到了再把电脑端的实验补上。

    运行结果

    摄像头实验

    内容

    OV2640

            OV2640 是 OV（OmniVision）公司生产的一颗 1/4 寸的 CMOS UXGA（1632*1232）图像传感器。该传感器体积小、工作电压低，提供单片 UXGA 摄像头和影像处理器的所有功能。通过 SCCB 总线控制，可以输出整帧、子采样、缩放和取窗口等方式的各种分辨率 8/10 位影像数据。该产品 UXGA 图像最高达到 15 帧/秒（SVGA 可达 30 帧，CIF 可达 60 帧）。用户可以完全控制图像质量、数据格式和传输方式。所有图像处理功能过程包括伽玛曲线、白平衡、对比度、色度等都可以通过 SCCB 接口编程。

    特点

    • 高灵敏度、低电压适合嵌入式应用
    • 标准的 SCCB 接口，兼容 IIC 接口
    • 支持 RawRGB、RGB(RGB565/RGB555)、GRB422、YUV(422/420)和 YCbCr（422） 输出格式
    • 支持 UXGA、SXGA、SVGA 以及按比例缩小到从 SXGA 到 40*30 的任何尺寸
    • 支持自动曝光控制、自动增益控制、自动白平衡、自动消除灯光条纹、自动黑电平校 准等自动控制功能。同时支持色饱和度、色相、伽马、锐度等设置。
    • 支持闪光灯
    • 支持图像缩放、平移和窗口设置
    • 支持图像压缩，即可输出 JPEG 图像数据
    • 自带嵌入式微处理器
    • UXGA ， 即 分 辨 率 位 1600*1200 的输出格式，类似的还有： SXGA(1280*1024) 、 WXGA+(1440*900)、XVGA(1280*960)、WXGA(1280*800)、XGA(1024*768)、SVGA(800*600)、 VGA(640*480)、CIF(352*288)、WQVGA(400*240)、QCIF(176*144)和 QQVGA(160*120)等。
    • PCLK，即像素时钟，一个 PCLK 时钟，输出一个像素(或半个像素)。
    • VSYNC，即帧同步信号。
    • HREF /HSYNC，即行同步信号。

            我们的数据输出（通过 Y[9:0]），就是通过PCLK，VSYNC和HREF /HSYNC来实现的，接下来我们就来讲解一下OV2640的时序部分。

    时序

            图像数据在 HREF 为高的时候输出，当 HREF 变高后，每一个 PCLK 时钟，输出一个 8 位/10 位数据。我们采用 8 位接口，所以每个 PCLK 输出 1 个字节，且在 RGB/YUV 输出格式下，每个 tp=2 个 Tpclk，如果是 Raw 格式，则一个 tp=1 个 Tpclk。比如我们采用 UXGA 时序，RGB565 格式输出，每 2 个字节组成一个像素的颜色（高低字节顺序可通过 0XDA 寄存器设置），这样每行输出总共有 1600*2 个 PCLK 周期，输出 1600*2 个字节。

    帧输出时序

            我们以UXGA举例， 首先VSYNC发送一个高电平数据表示起始信号，然后在HREF为高电平期间采集有效数据，一共1600条，然后重复1200次，就达到了输出的效果。

    窗口设置

            传感器窗口设置，该功能允许用户设置整个传感器区域（1632*1220）的感兴趣部分，也就是在传感器里面开窗，开窗范围从 2*2~1632*1220 都可以设置，不过要求这个窗口必须大于等于随后设置的图像尺寸。传感器窗口设置，通过：0X03/0X19/0X1A/0X07/0X17/0X18 等寄存器设置，使用的函数是OV2640_Window_Set。

            图像尺寸设置，也就是 DSP 输出（最终输出到 LCD 的）图像的最大尺寸，该尺寸要小于等于前面我们传感器窗口设置所设定的窗口尺寸。图像尺寸通过：0XC0/0XC1/0X8C 等寄存器设置。使用的函数是OV2640_ImageSize_Set。

            图像窗口设置，这里起始和前面的传感器窗口设置类似，只是这个窗口是在我们前面设置的图像尺寸里面，再一次设置窗口大小，该窗口必须小于等于前面设置的图像尺寸。该窗口设置后的图像范围，将用于输出到外部。图像窗口设置通过：0X51/0X52/0X53/0X54/0X55/0X57等寄存器设置。使用的函数是OV2640_ImageWin_Set。

            图像输出大小设置，这是最终输出到外部的图像尺寸。该设置将图像窗口设置所决定的窗口大小，通过内部 DSP 处理，缩放成我们输出到外部的图像大小。该设置将会对图像进行缩放处理，如果设置的图像输出大小不等于图像窗口设置图像大小，那么图像就会被缩放处理，只有这两者设置一样大的时候，输出比例才是 1：1 的。使用的函数是OV2640_OutSize_Set。

    整体效果如下所示

    配置

    初始化

            这是初始化的流程，首先初始化好IO口，然后上电复位，读取ID，执行初始化序列，这个是OV2640厂家做好的，我们就不需要重新写过了。 

     读取图像数据

    DCMI

            STM32F4 自带了一个数字摄像头（DCMI）接口，该接口是一个同步并行接口，能够接收外部 8 位、10 位、12 位或 14 位 CMOS 摄像头模块发出的高速数据流。可支持不同的数据格式：YCbCr4:2:2/RGB565 逐行视频和压缩数据 (JPEG)。

            DCMI 接口是一个同步并行接口，可接收高速（可达 54 MB/s）数据流。该接口包含多达14 条数据线(D13-D0)和一条像素时钟线(PIXCLK)。像素时钟的极性可以编程，因此可以在像素时钟的上升沿或下降沿捕获数据。

    特点

    • 8 位、10 位、12 位或 14 位并行接口
    • 内嵌码/外部行同步和帧同步
    • 连续模式或快照模式
    • 裁剪功能
    • 支持以下数据格式：
      • 8/10/12/14 位逐行视频：单色或原始拜尔（Bayer）格式
      • YCbCr 4:2:2 逐行视频
      • RGB 565 逐行视频
      • 压缩数据：JPEG

    信号

    1. 数据输入（D[0:13]），用于接摄像头的数据输出，接 OV2640 我们只用了 8 位数据。
    2. 水平同步（行同步）输入（HSYNC），用于接摄像头的 HSYNC/HREF 信号。
    3. 垂直同步（场同步）输入（VSYNC），用于接摄像头的 VSYNC 信号。
    4. 像素时钟输入（PIXCLK），用于接摄像头的 PCLK 信号。

            DCMI 接口的数据与 PIXCLK（即 PCLK）保持同步，并根据像素时钟的极性在像素时钟上升沿/下降沿发生变化。HSYNC（HREF）信号指示行的开始/结束，VSYNC 信号指示帧的开始/结束。DCMI 信号波形如图所示：

            上图中，对应设置为：DCMI_PIXCLK 的捕获沿为下降沿，DCMI_HSYNC 和 DCMI_VSYNC 的有效状态为 1，注意，这里的有效状态实际上对应的是指示数据在并行接口上无效时， HSYNC/VSYNC 引脚上面的引脚电平。

            我们用到 DCMI 的 8 位数据宽度，通过设置 DCMI_CR 中的 EDM[1:0]=00 设置。此时 DCMI_D0~D7 有效，DCMI_D8~D13 上的数据则忽略，这个时候，每次需要 4 个像素时钟来捕获一个 32 位数据。捕获的第一个数据存放在 32 位字的 LSB 位置，第四个数据存放在 32 位字的 MSB 位置 ，捕获数据字节在 32 位字中的排布如表所示：

    DMA

            DCMI 接口支持 DMA 传输，当 DCMI_CR 寄存器中的 CAPTURE 位置 1 时，激活 DMA 接口。摄像头接口每次在其寄存器中收到一个完整的 32 位数据块时，都将触发一个 DMA请求。

    寄存器

            寄存器就不详细介绍了。

    配置

    1. 配置 OV2640 控制引脚，并配置 OV2640 工作模式。
    2. 配置相关引脚的模式和复用功能（AF13），使能时钟。
    3. 配置 DCMI 相关设置。
    4. 配置 DMA。
    5. 设置 OV2640 的图像输出大小，使能 DCMI 捕获。

    硬件连接

    代码

    1. //dcmi.c
    2. #include "sys.h"
    3. #include "dcmi.h"  
    4. #include "led.h" 
    5. #include "ov2640.h" 
    6.  
    7. u8 ov_frame=0;  						//帧率
    8. extern void jpeg_data_process(void);	//JPEG数据处理函数
    9.  
    10. DCMI_InitTypeDef DCMI_InitStructure;
    11.  
    12. //DCMI中断服务函数
    13. void DCMI_IRQHandler(void)
    14. {
    15. 	if(DCMI_GetITStatus(DCMI_IT_FRAME)==SET)//捕获到一帧图像
    16. 	{
    17. 		jpeg_data_process(); 	//jpeg数据处理	
    18. 		DCMI_ClearITPendingBit(DCMI_IT_FRAME);//清除帧中断
    19. 		LED1=!LED1;
    20. 		ov_frame++;  
    21. 	}
    22. } 
    23. //DCMI DMA配置
    24. //DMA_Memory0BaseAddr:存储器地址    将要存储摄像头数据的内存地址(也可以是外设地址)
    25. //DMA_BufferSize:存储器长度    0~65535
    26. //DMA_MemoryDataSize:存储器位宽  
    27. //DMA_MemoryDataSize:存储器位宽    @defgroup DMA_memory_data_size :DMA_MemoryDataSize_Byte/DMA_MemoryDataSize_HalfWord/DMA_MemoryDataSize_Word
    28. //DMA_MemoryInc:存储器增长方式  @defgroup DMA_memory_incremented_mode  /** @defgroup DMA_memory_incremented_mode : DMA_MemoryInc_Enable/DMA_MemoryInc_Disable
    29. void DCMI_DMA_Init(u32 DMA_Memory0BaseAddr,u16 DMA_BufferSize,u32 DMA_MemoryDataSize,u32 DMA_MemoryInc)
    30. { 
    31. 	DMA_InitTypeDef  DMA_InitStructure;
    32. 	
    33.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2,ENABLE);//DMA2时钟使能 
    34. 	DMA_DeInit(DMA2_Stream1);
    35. 	while (DMA_GetCmdStatus(DMA2_Stream1) != DISABLE){}//等待DMA2_Stream1可配置 
    36. 	
    37.   /* 配置 DMA Stream */
    38.   DMA_InitStructure.DMA_Channel = DMA_Channel_1;  //通道1 DCMI通道 
    39.   DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&DCMI->DR;//外设地址为:DCMI->DR
    40.   DMA_InitStructure.DMA_Memory0BaseAddr = DMA_Memory0BaseAddr;//DMA 存储器0地址
    41.   DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;//外设到存储器模式
    42.   DMA_InitStructure.DMA_BufferSize = DMA_BufferSize;//数据传输量 
    43.   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//外设非增量模式
    44.   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc;//存储器增量模式
    45.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;//外设数据长度:32位
    46.   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize;//存储器数据长度 
    47.   DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;// 使用循环模式 
    48.   DMA_InitStructure.DMA_Priority = DMA_Priority_High;//高优先级
    49.   DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable; //FIFO模式        
    50.   DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;//使用全FIFO 
    51.   DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;//外设突发单次传输
    52.   DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;//存储器突发单次传输
    53.   DMA_Init(DMA2_Stream1, &DMA_InitStructure);//初始化DMA Stream
    54. 	
    55. } 
    56. //DCMI初始化
    57. void My_DCMI_Init(void)
    58. {
    59.   GPIO_InitTypeDef  GPIO_InitStructure;
    60. 	NVIC_InitTypeDef NVIC_InitStructure;
    61.  
    62. 	
    63.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA|RCC_AHB1Periph_GPIOB|RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOE, ENABLE);//使能GPIOA B C E 时钟
    64. 	RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_DCMI,ENABLE);//使能DCMI时钟
    65.   //PA4/6初始化设置
    66.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4|GPIO_Pin_6;//PA4/6   复用功能输出
    67.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; //复用功能输出
    68.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    69.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    70.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    71.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化
    72. 	
    73.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7|GPIO_Pin_6;// PB6/7   复用功能输出
    74.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    75. 	
    76.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_11;//PC6/7/8/9/11 复用功能输出
    77.   GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化	
    78.  
    79.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6;//PE5/6  复用功能输出 
    80.   GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化	
    81.  
    82. 	GPIO_PinAFConfig(GPIOA,GPIO_PinSource4,GPIO_AF_DCMI); //PA4,AF13  DCMI_HSYNC
    83. 	GPIO_PinAFConfig(GPIOA,GPIO_PinSource6,GPIO_AF_DCMI); //PA6,AF13  DCMI_PCLK  
    84.  	GPIO_PinAFConfig(GPIOB,GPIO_PinSource7,GPIO_AF_DCMI); //PB7,AF13  DCMI_VSYNC 
    85.  	GPIO_PinAFConfig(GPIOC,GPIO_PinSource6,GPIO_AF_DCMI); //PC6,AF13  DCMI_D0  
    86.  	GPIO_PinAFConfig(GPIOC,GPIO_PinSource7,GPIO_AF_DCMI); //PC7,AF13  DCMI_D1 
    87. 	GPIO_PinAFConfig(GPIOC,GPIO_PinSource8,GPIO_AF_DCMI); //PC8,AF13  DCMI_D2
    88. 	GPIO_PinAFConfig(GPIOC,GPIO_PinSource9,GPIO_AF_DCMI); //PC9,AF13  DCMI_D3
    89. 	GPIO_PinAFConfig(GPIOC,GPIO_PinSource11,GPIO_AF_DCMI);//PC11,AF13 DCMI_D4 
    90. 	GPIO_PinAFConfig(GPIOB,GPIO_PinSource6,GPIO_AF_DCMI); //PB6,AF13  DCMI_D5 
    91. 	GPIO_PinAFConfig(GPIOE,GPIO_PinSource5,GPIO_AF_DCMI); //PE5,AF13  DCMI_D6
    92. 	GPIO_PinAFConfig(GPIOE,GPIO_PinSource6,GPIO_AF_DCMI); //PE6,AF13  DCMI_D7
    93.  
    94. 	
    95. 	DCMI_DeInit();//清除原来的设置 
    96.  
    97.  
    98. 	DCMI_InitStructure.DCMI_CaptureMode=DCMI_CaptureMode_Continuous;//连续模式
    99. 	DCMI_InitStructure.DCMI_CaptureRate=DCMI_CaptureRate_All_Frame;//全帧捕获
    100. 	DCMI_InitStructure.DCMI_ExtendedDataMode= DCMI_ExtendedDataMode_8b;//8位数据格式  
    101. 	DCMI_InitStructure.DCMI_HSPolarity= DCMI_HSPolarity_Low;//HSYNC 低电平有效
    102. 	DCMI_InitStructure.DCMI_PCKPolarity= DCMI_PCKPolarity_Rising;//PCLK 上升沿有效
    103. 	DCMI_InitStructure.DCMI_SynchroMode= DCMI_SynchroMode_Hardware;//硬件同步HSYNC,VSYNC
    104. 	DCMI_InitStructure.DCMI_VSPolarity=DCMI_VSPolarity_Low;//VSYNC 低电平有效
    105. 	DCMI_Init(&DCMI_InitStructure);
    106.  
    107. 	DCMI_ITConfig(DCMI_IT_FRAME,ENABLE);//开启帧中断 
    108. 	
    109. 	DCMI_Cmd(ENABLE);	//DCMI使能
    110.  
    111.   NVIC_InitStructure.NVIC_IRQChannel = DCMI_IRQn;
    112. 	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;//抢占优先级1
    113. 	NVIC_InitStructure.NVIC_IRQChannelSubPriority =0;		//子优先级3
    114. 	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能
    115. 	NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器、
    116.  
    117. } 
    118. //DCMI,启动传输
    119. void DCMI_Start(void)
    120. {  
    121. 	DMA_Cmd(DMA2_Stream1, ENABLE);//开启DMA2,Stream1 
    122. 	DCMI_CaptureCmd(ENABLE);//DCMI捕获使能  
    123. }
    124. //DCMI,关闭传输
    125. void DCMI_Stop(void)
    126. { 
    127.   DCMI_CaptureCmd(DISABLE);//DCMI捕获使关闭	
    128. 	
    129. 	while(DCMI->CR&0X01);		//等待传输结束 
    130. 	 	
    131. 	DMA_Cmd(DMA2_Stream1,DISABLE);//关闭DMA2,Stream1
    132. } 
    133.  
    134. //以下两个函数,供usmart调用,用于调试代码
    135.  
    136. //DCMI设置显示窗口
    137. //sx,sy;LCD的起始坐标
    138. //width,height:LCD显示范围.
    139. void DCMI_Set_Window(u16 sx,u16 sy,u16 width,u16 height)
    140. {
    141. 	DCMI_Stop(); 
    142. //	LCD_Clear(WHITE);
    143. //	LCD_Set_Window(sx,sy,width,height);
    144. 	OV2640_OutSize_Set(width,height);
    145. //  LCD_SetCursor(0,0);  
    146. //	LCD_WriteRAM_Prepare();		//开始写入GRAM
    147. 	
    148. 	DMA_Cmd(DMA2_Stream1,ENABLE);	//开启DMA2,Stream1 
    149. 	
    150. 	DCMI_CaptureCmd(ENABLE);//DCMI捕获使能 
    151. 	
    152. }
    153.    
    154. //通过usmart调试,辅助测试用.
    155. //pclk/hsync/vsync:三个信号的有限电平设置
    156. void DCMI_CR_Set(u8 pclk,u8 hsync,u8 vsync)
    157. {
    158. 	DCMI_DeInit();//清除原来的设置 
    159.  
    160.   DCMI_InitStructure.DCMI_CaptureMode=DCMI_CaptureMode_Continuous;//连续模式
    161. 	DCMI_InitStructure.DCMI_CaptureRate=DCMI_CaptureRate_All_Frame;//全帧捕获
    162. 	DCMI_InitStructure.DCMI_ExtendedDataMode= DCMI_ExtendedDataMode_8b;//8位数据格式  
    163. 	DCMI_InitStructure.DCMI_HSPolarity= hsync<<6;//HSYNC 低电平有效
    164. 	DCMI_InitStructure.DCMI_PCKPolarity= pclk<<5;//PCLK 上升沿有效
    165. 	DCMI_InitStructure.DCMI_SynchroMode= DCMI_SynchroMode_Hardware;//硬件同步HSYNC,VSYNC
    166. 	DCMI_InitStructure.DCMI_VSPolarity=vsync<<7;//VSYNC 低电平有效
    167. 	DCMI_Init(&DCMI_InitStructure);
    168.  
    169. 	DCMI_CaptureCmd(ENABLE);//DCMI捕获使能 
    170. 	DCMI_Cmd(ENABLE);	//DCMI使能
    171.   
    172. }
    1. // sccb.c
    2. #include "sys.h"
    3. #include "sccb.h"
    4. #include "delay.h"
    5.  
    6. //初始化SCCB接口 
    7. void SCCB_Init(void)
    8. {				
    9.   GPIO_InitTypeDef  GPIO_InitStructure;
    10.  
    11.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);//使能GPIOD时钟
    12.   //GPIOF9,F10初始化设置
    13.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;//PD6,7 推挽输出
    14.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;  //PD6,7 推挽输出
    15.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    16.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//100MHz
    17.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    18.   GPIO_Init(GPIOD, &GPIO_InitStructure);//初始化
    19.  
    20. 	GPIO_SetBits(GPIOD,GPIO_Pin_6|GPIO_Pin_7);
    21. 	SCCB_SDA_OUT();	   
    22. }			 
    23.  
    24. //SCCB起始信号
    25. //当时钟为高的时候,数据线的高到低,为SCCB起始信号
    26. //在激活状态下,SDA和SCL均为低电平
    27. void SCCB_Start(void)
    28. {
    29.     SCCB_SDA=1;     //数据线高电平	   
    30.     SCCB_SCL=1;	    //在时钟线高的时候数据线由高至低
    31.     delay_us(50);  
    32.     SCCB_SDA=0;
    33.     delay_us(50);	 
    34.     SCCB_SCL=0;	    //数据线恢复低电平，单操作函数必要	  
    35. }
    36.  
    37. //SCCB停止信号
    38. //当时钟为高的时候,数据线的低到高,为SCCB停止信号
    39. //空闲状况下,SDA,SCL均为高电平
    40. void SCCB_Stop(void)
    41. {
    42.     SCCB_SDA=0;
    43.     delay_us(50);	 
    44.     SCCB_SCL=1;	
    45.     delay_us(50); 
    46.     SCCB_SDA=1;	
    47.     delay_us(50);
    48. }  
    49. //产生NA信号
    50. void SCCB_No_Ack(void)
    51. {
    52. 	delay_us(50);
    53. 	SCCB_SDA=1;	
    54. 	SCCB_SCL=1;	
    55. 	delay_us(50);
    56. 	SCCB_SCL=0;	
    57. 	delay_us(50);
    58. 	SCCB_SDA=0;	
    59. 	delay_us(50);
    60. }
    61. //SCCB,写入一个字节
    62. //返回值:0,成功;1,失败. 
    63. u8 SCCB_WR_Byte(u8 dat)
    64. {
    65. 	u8 j,res;	 
    66. 	for(j=0;j<8;j++) //循环8次发送数据
    67. 	{
    68. 		if(dat&0x80)SCCB_SDA=1;	
    69. 		else SCCB_SDA=0;
    70. 		dat<<=1;
    71. 		delay_us(50);
    72. 		SCCB_SCL=1;	
    73. 		delay_us(50);
    74. 		SCCB_SCL=0;		   
    75. 	}			 
    76. 	SCCB_SDA_IN();		//设置SDA为输入 
    77. 	delay_us(50);
    78. 	SCCB_SCL=1;			//接收第九位,以判断是否发送成功
    79. 	delay_us(50);
    80. 	if(SCCB_READ_SDA)res=1;  //SDA=1发送失败，返回1
    81. 	else res=0;         //SDA=0发送成功，返回0
    82. 	SCCB_SCL=0;		 
    83. 	SCCB_SDA_OUT();		//设置SDA为输出    
    84. 	return res;  
    85. }	 
    86. //SCCB 读取一个字节
    87. //在SCL的上升沿,数据锁存
    88. //返回值:读到的数据
    89. u8 SCCB_RD_Byte(void)
    90. {
    91. 	u8 temp=0,j;    
    92. 	SCCB_SDA_IN();		//设置SDA为输入  
    93. 	for(j=8;j>0;j--) 	//循环8次接收数据
    94. 	{		     	  
    95. 		delay_us(50);
    96. 		SCCB_SCL=1;
    97. 		temp=temp<<1;
    98. 		if(SCCB_READ_SDA)temp++;   
    99. 		delay_us(50);
    100. 		SCCB_SCL=0;
    101. 	}	
    102. 	SCCB_SDA_OUT();		//设置SDA为输出    
    103. 	return temp;
    104. } 							    
    105. //写寄存器
    106. //返回值:0,成功;1,失败.
    107. u8 SCCB_WR_Reg(u8 reg,u8 data)
    108. {
    109. 	u8 res=0;
    110. 	SCCB_Start(); 					//启动SCCB传输
    111. 	if(SCCB_WR_Byte(SCCB_ID))res=1;	//写器件ID	  
    112. 	delay_us(100);
    113.   	if(SCCB_WR_Byte(reg))res=1;		//写寄存器地址	  
    114. 	delay_us(100);
    115.   	if(SCCB_WR_Byte(data))res=1; 	//写数据	 
    116.   	SCCB_Stop();	  
    117.   	return	res;
    118. }		  					    
    119. //读寄存器
    120. //返回值:读到的寄存器值
    121. u8 SCCB_RD_Reg(u8 reg)
    122. {
    123. 	u8 val=0;
    124. 	SCCB_Start(); 				//启动SCCB传输
    125. 	SCCB_WR_Byte(SCCB_ID);		//写器件ID	  
    126. 	delay_us(100);	 
    127.   	SCCB_WR_Byte(reg);			//写寄存器地址	  
    128. 	delay_us(100);	  
    129. 	SCCB_Stop();   
    130. 	delay_us(100);	   
    131. 	//设置寄存器地址后，才是读
    132. 	SCCB_Start();
    133. 	SCCB_WR_Byte(SCCB_ID|0X01);	//发送读命令	  
    134. 	delay_us(100);
    135.   	val=SCCB_RD_Byte();		 	//读取数据
    136.   	SCCB_No_Ack();
    137.   	SCCB_Stop();
    138.   	return val;
    139. }
    1. //ov2640.c
    2. #include "sys.h"
    3. #include "ov2640.h"
    4. #include "ov2640cfg.h"
    5. #include "timer.h"	  
    6. #include "delay.h"
    7. #include "usart.h"			 
    8. #include "sccb.h"	
    9.   
    10. //初始化OV2640 
    11. //配置完以后,默认输出是1600*1200尺寸的图片!! 
    12. //返回值:0,成功
    13. //    其他,错误代码
    14. u8 OV2640_Init(void)
    15. { 
    16. 	u16 i=0;
    17. 	u16 reg;
    18. 	//设置IO     	   
    19.   GPIO_InitTypeDef  GPIO_InitStructure;
    20.  
    21.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);
    22.   //GPIOG9,15初始化设置
    23.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9|GPIO_Pin_15;//PG9,15推挽输出
    24.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //推挽输出
    25.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    26.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//100MHz
    27.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    28.   GPIO_Init(GPIOG, &GPIO_InitStructure);//初始化
    29.  
    30.  	OV2640_PWDN=0;	//POWER ON
    31. 	delay_ms(10);
    32. 	OV2640_RST=0;	//复位OV2640
    33. 	delay_ms(10);
    34. 	OV2640_RST=1;	//结束复位 
    35. 	SCCB_Init();        		//初始化SCCB 的IO口	 
    36. 	SCCB_WR_Reg(OV2640_DSP_RA_DLMT, 0x01);	//操作sensor寄存器
    37.  	SCCB_WR_Reg(OV2640_SENSOR_COM7, 0x80);	//软复位OV2640
    38. 	delay_ms(50); 
    39. 	reg=SCCB_RD_Reg(OV2640_SENSOR_MIDH);	//读取厂家ID 高八位
    40. 	reg<<=8;
    41. 	reg|=SCCB_RD_Reg(OV2640_SENSOR_MIDL);	//读取厂家ID 低八位
    42. 	if(reg!=OV2640_MID)
    43. 	{
    44. 		printf("MID:%d\r\n",reg);
    45. 		return 1;
    46. 	}
    47. 	reg=SCCB_RD_Reg(OV2640_SENSOR_PIDH);	//读取厂家ID 高八位
    48. 	reg<<=8;
    49. 	reg|=SCCB_RD_Reg(OV2640_SENSOR_PIDL);	//读取厂家ID 低八位
    50. 	if(reg!=OV2640_PID)
    51. 	{
    52. 		printf("HID:%d\r\n",reg);
    53. 		return 2;
    54. 	}   
    55.  	//初始化 OV2640,采用UXGA分辨率(1600*1200)  
    56. 	for(i=0;i<sizeof(ov2640_uxga_init_reg_tbl)/2;i++)
    57. 	{
    58. 	   	SCCB_WR_Reg(ov2640_uxga_init_reg_tbl[i][0],ov2640_uxga_init_reg_tbl[i][1]);
    59.  	} 
    60.   	return 0x00; 	//ok
    61. } 
    62. //OV2640切换为JPEG模式
    63. void OV2640_JPEG_Mode(void) 
    64. {
    65. 	u16 i=0;
    66. 	//设置:YUV422格式
    67. 	for(i=0;i<(sizeof(ov2640_yuv422_reg_tbl)/2);i++)
    68. 	{
    69. 		SCCB_WR_Reg(ov2640_yuv422_reg_tbl[i][0],ov2640_yuv422_reg_tbl[i][1]); 
    70. 	} 
    71. 	
    72. 	//设置:输出JPEG数据
    73. 	for(i=0;i<(sizeof(ov2640_jpeg_reg_tbl)/2);i++)
    74. 	{
    75. 		SCCB_WR_Reg(ov2640_jpeg_reg_tbl[i][0],ov2640_jpeg_reg_tbl[i][1]);  
    76. 	}  
    77. }
    78. //OV2640切换为RGB565模式
    79. void OV2640_RGB565_Mode(void) 
    80. {
    81. 	u16 i=0;
    82. 	//设置:RGB565输出
    83. 	for(i=0;i<(sizeof(ov2640_rgb565_reg_tbl)/2);i++)
    84. 	{
    85. 		SCCB_WR_Reg(ov2640_rgb565_reg_tbl[i][0],ov2640_rgb565_reg_tbl[i][1]); 
    86. 	} 
    87. } 
    88. //自动曝光设置参数表,支持5个等级
    89. const static u8 OV2640_AUTOEXPOSURE_LEVEL[5][8]=
    90. {
    91. 	{
    92. 		0xFF,0x01,
    93. 		0x24,0x20,
    94. 		0x25,0x18,
    95. 		0x26,0x60,
    96. 	},
    97. 	{
    98. 		0xFF,0x01,
    99. 		0x24,0x34,
    100. 		0x25,0x1c,
    101. 		0x26,0x00,
    102. 	},
    103. 	{
    104. 		0xFF,0x01,	
    105. 		0x24,0x3e,	
    106. 		0x25,0x38,
    107. 		0x26,0x81,
    108. 	},
    109. 	{
    110. 		0xFF,0x01,
    111. 		0x24,0x48,
    112. 		0x25,0x40,
    113. 		0x26,0x81,
    114. 	},
    115. 	{
    116. 		0xFF,0x01,	
    117. 		0x24,0x58,	
    118. 		0x25,0x50,	
    119. 		0x26,0x92,	
    120. 	},
    121. }; 
    122. //OV2640自动曝光等级设置
    123. //level:0~4
    124. void OV2640_Auto_Exposure(u8 level)
    125. {  
    126. 	u8 i;
    127. 	u8 *p=(u8*)OV2640_AUTOEXPOSURE_LEVEL[level];
    128. 	for(i=0;i<4;i++)
    129. 	{ 
    130. 		SCCB_WR_Reg(p[i*2],p[i*2+1]); 
    131. 	} 
    132. }  
    133. //白平衡设置
    134. //0:自动
    135. //1:太阳sunny
    136. //2,阴天cloudy
    137. //3,办公室office
    138. //4,家里home
    139. void OV2640_Light_Mode(u8 mode)
    140. {
    141. 	u8 regccval=0X5E;//Sunny 
    142. 	u8 regcdval=0X41;
    143. 	u8 regceval=0X54;
    144. 	switch(mode)
    145. 	{ 
    146. 		case 0://auto 
    147. 			SCCB_WR_Reg(0XFF,0X00);	 
    148. 			SCCB_WR_Reg(0XC7,0X10);//AWB ON 
    149. 			return;  	
    150. 		case 2://cloudy
    151. 			regccval=0X65;
    152. 			regcdval=0X41;
    153. 			regceval=0X4F;
    154. 			break;	
    155. 		case 3://office
    156. 			regccval=0X52;
    157. 			regcdval=0X41;
    158. 			regceval=0X66;
    159. 			break;	
    160. 		case 4://home
    161. 			regccval=0X42;
    162. 			regcdval=0X3F;
    163. 			regceval=0X71;
    164. 			break;	
    165. 	}
    166. 	SCCB_WR_Reg(0XFF,0X00);	 
    167. 	SCCB_WR_Reg(0XC7,0X40);	//AWB OFF 
    168. 	SCCB_WR_Reg(0XCC,regccval); 
    169. 	SCCB_WR_Reg(0XCD,regcdval); 
    170. 	SCCB_WR_Reg(0XCE,regceval);  
    171. }
    172. //色度设置
    173. //0:-2
    174. //1:-1
    175. //2,0
    176. //3,+1
    177. //4,+2
    178. void OV2640_Color_Saturation(u8 sat)
    179. { 
    180. 	u8 reg7dval=((sat+2)<<4)|0X08;
    181. 	SCCB_WR_Reg(0XFF,0X00);		
    182. 	SCCB_WR_Reg(0X7C,0X00);		
    183. 	SCCB_WR_Reg(0X7D,0X02);				
    184. 	SCCB_WR_Reg(0X7C,0X03);			
    185. 	SCCB_WR_Reg(0X7D,reg7dval);			
    186. 	SCCB_WR_Reg(0X7D,reg7dval); 		
    187. }
    188. //亮度设置
    189. //0:(0X00)-2
    190. //1:(0X10)-1
    191. //2,(0X20) 0
    192. //3,(0X30)+1
    193. //4,(0X40)+2
    194. void OV2640_Brightness(u8 bright)
    195. {
    196.   SCCB_WR_Reg(0xff, 0x00);
    197.   SCCB_WR_Reg(0x7c, 0x00);
    198.   SCCB_WR_Reg(0x7d, 0x04);
    199.   SCCB_WR_Reg(0x7c, 0x09);
    200.   SCCB_WR_Reg(0x7d, bright<<4); 
    201.   SCCB_WR_Reg(0x7d, 0x00); 
    202. }
    203. //对比度设置
    204. //0:-2
    205. //1:-1
    206. //2,0
    207. //3,+1
    208. //4,+2
    209. void OV2640_Contrast(u8 contrast)
    210. {
    211. 	u8 reg7d0val=0X20;//默认为普通模式
    212. 	u8 reg7d1val=0X20;
    213.   	switch(contrast)
    214. 	{
    215. 		case 0://-2
    216. 			reg7d0val=0X18;	 	 
    217. 			reg7d1val=0X34;	 	 
    218. 			break;	
    219. 		case 1://-1
    220. 			reg7d0val=0X1C;	 	 
    221. 			reg7d1val=0X2A;	 	 
    222. 			break;	
    223. 		case 3://1
    224. 			reg7d0val=0X24;	 	 
    225. 			reg7d1val=0X16;	 	 
    226. 			break;	
    227. 		case 4://2
    228. 			reg7d0val=0X28;	 	 
    229. 			reg7d1val=0X0C;	 	 
    230. 			break;	
    231. 	}
    232. 	SCCB_WR_Reg(0xff,0x00);
    233. 	SCCB_WR_Reg(0x7c,0x00);
    234. 	SCCB_WR_Reg(0x7d,0x04);
    235. 	SCCB_WR_Reg(0x7c,0x07);
    236. 	SCCB_WR_Reg(0x7d,0x20);
    237. 	SCCB_WR_Reg(0x7d,reg7d0val);
    238. 	SCCB_WR_Reg(0x7d,reg7d1val);
    239. 	SCCB_WR_Reg(0x7d,0x06);
    240. }
    241. //特效设置
    242. //0:普通模式    
    243. //1,负片
    244. //2,黑白   
    245. //3,偏红色
    246. //4,偏绿色
    247. //5,偏蓝色
    248. //6,复古	    
    249. void OV2640_Special_Effects(u8 eft)
    250. {
    251. 	u8 reg7d0val=0X00;//默认为普通模式
    252. 	u8 reg7d1val=0X80;
    253. 	u8 reg7d2val=0X80; 
    254. 	switch(eft)
    255. 	{
    256. 		case 1://负片
    257. 			reg7d0val=0X40; 
    258. 			break;	
    259. 		case 2://黑白
    260. 			reg7d0val=0X18; 
    261. 			break;	 
    262. 		case 3://偏红色
    263. 			reg7d0val=0X18; 
    264. 			reg7d1val=0X40;
    265. 			reg7d2val=0XC0; 
    266. 			break;	
    267. 		case 4://偏绿色
    268. 			reg7d0val=0X18; 
    269. 			reg7d1val=0X40;
    270. 			reg7d2val=0X40; 
    271. 			break;	
    272. 		case 5://偏蓝色
    273. 			reg7d0val=0X18; 
    274. 			reg7d1val=0XA0;
    275. 			reg7d2val=0X40; 
    276. 			break;	
    277. 		case 6://复古
    278. 			reg7d0val=0X18; 
    279. 			reg7d1val=0X40;
    280. 			reg7d2val=0XA6; 
    281. 			break;	 
    282. 	}
    283. 	SCCB_WR_Reg(0xff,0x00);
    284. 	SCCB_WR_Reg(0x7c,0x00);
    285. 	SCCB_WR_Reg(0x7d,reg7d0val);
    286. 	SCCB_WR_Reg(0x7c,0x05);
    287. 	SCCB_WR_Reg(0x7d,reg7d1val);
    288. 	SCCB_WR_Reg(0x7d,reg7d2val); 
    289. }
    290. //彩条测试
    291. //sw:0,关闭彩条
    292. //   1,开启彩条(注意OV2640的彩条是叠加在图像上面的)
    293. void OV2640_Color_Bar(u8 sw)
    294. {
    295. 	u8 reg;
    296. 	SCCB_WR_Reg(0XFF,0X01);
    297. 	reg=SCCB_RD_Reg(0X12);
    298. 	reg&=~(1<<1);
    299. 	if(sw)reg|=1<<1; 
    300. 	SCCB_WR_Reg(0X12,reg);
    301. }
    302. //设置图像输出窗口 
    303. //sx,sy,起始地址
    304. //width,height:宽度(对应:horizontal)和高度(对应:vertical)
    305. void OV2640_Window_Set(u16 sx,u16 sy,u16 width,u16 height)
    306. {
    307. 	u16 endx;
    308. 	u16 endy;
    309. 	u8 temp; 
    310. 	endx=sx+width/2;	//V*2
    311.  	endy=sy+height/2;
    312. 	
    313. 	SCCB_WR_Reg(0XFF,0X01);			
    314. 	temp=SCCB_RD_Reg(0X03);				//读取Vref之前的值
    315. 	temp&=0XF0;
    316. 	temp|=((endy&0X03)<<2)|(sy&0X03);
    317. 	SCCB_WR_Reg(0X03,temp);				//设置Vref的start和end的最低2位
    318. 	SCCB_WR_Reg(0X19,sy>>2);			//设置Vref的start高8位
    319. 	SCCB_WR_Reg(0X1A,endy>>2);			//设置Vref的end的高8位
    320. 	
    321. 	temp=SCCB_RD_Reg(0X32);				//读取Href之前的值
    322. 	temp&=0XC0;
    323. 	temp|=((endx&0X07)<<3)|(sx&0X07);
    324. 	SCCB_WR_Reg(0X32,temp);				//设置Href的start和end的最低3位
    325. 	SCCB_WR_Reg(0X17,sx>>3);			//设置Href的start高8位
    326. 	SCCB_WR_Reg(0X18,endx>>3);			//设置Href的end的高8位
    327. }
    328. //设置图像输出大小
    329. //OV2640输出图像的大小(分辨率),完全由改函数确定
    330. //width,height:宽度(对应:horizontal)和高度(对应:vertical),width和height必须是4的倍数
    331. //返回值:0,设置成功
    332. //    其他,设置失败
    333. u8 OV2640_OutSize_Set(u16 width,u16 height)
    334. {
    335. 	u16 outh;
    336. 	u16 outw;
    337. 	u8 temp; 
    338. 	if(width%4)return 1;
    339. 	if(height%4)return 2;
    340. 	outw=width/4;
    341. 	outh=height/4; 
    342. 	SCCB_WR_Reg(0XFF,0X00);	
    343. 	SCCB_WR_Reg(0XE0,0X04);			
    344. 	SCCB_WR_Reg(0X5A,outw&0XFF);		//设置OUTW的低八位
    345. 	SCCB_WR_Reg(0X5B,outh&0XFF);		//设置OUTH的低八位
    346. 	temp=(outw>>8)&0X03;
    347. 	temp|=(outh>>6)&0X04;
    348. 	SCCB_WR_Reg(0X5C,temp);				//设置OUTH/OUTW的高位 
    349. 	SCCB_WR_Reg(0XE0,0X00);	
    350. 	return 0;
    351. }
    352. //设置图像开窗大小
    353. //由:OV2640_ImageSize_Set确定传感器输出分辨率从大小.
    354. //该函数则在这个范围上面进行开窗,用于OV2640_OutSize_Set的输出
    355. //注意:本函数的宽度和高度,必须大于等于OV2640_OutSize_Set函数的宽度和高度
    356. //     OV2640_OutSize_Set设置的宽度和高度,根据本函数设置的宽度和高度,由DSP
    357. //     自动计算缩放比例,输出给外部设备.
    358. //width,height:宽度(对应:horizontal)和高度(对应:vertical),width和height必须是4的倍数
    359. //返回值:0,设置成功
    360. //    其他,设置失败
    361. u8 OV2640_ImageWin_Set(u16 offx,u16 offy,u16 width,u16 height)
    362. {
    363. 	u16 hsize;
    364. 	u16 vsize;
    365. 	u8 temp; 
    366. 	if(width%4)return 1;
    367. 	if(height%4)return 2;
    368. 	hsize=width/4;
    369. 	vsize=height/4;
    370. 	SCCB_WR_Reg(0XFF,0X00);	
    371. 	SCCB_WR_Reg(0XE0,0X04);					
    372. 	SCCB_WR_Reg(0X51,hsize&0XFF);		//设置H_SIZE的低八位
    373. 	SCCB_WR_Reg(0X52,vsize&0XFF);		//设置V_SIZE的低八位
    374. 	SCCB_WR_Reg(0X53,offx&0XFF);		//设置offx的低八位
    375. 	SCCB_WR_Reg(0X54,offy&0XFF);		//设置offy的低八位
    376. 	temp=(vsize>>1)&0X80;
    377. 	temp|=(offy>>4)&0X70;
    378. 	temp|=(hsize>>5)&0X08;
    379. 	temp|=(offx>>8)&0X07; 
    380. 	SCCB_WR_Reg(0X55,temp);				//设置H_SIZE/V_SIZE/OFFX,OFFY的高位
    381. 	SCCB_WR_Reg(0X57,(hsize>>2)&0X80);	//设置H_SIZE/V_SIZE/OFFX,OFFY的高位
    382. 	SCCB_WR_Reg(0XE0,0X00);	
    383. 	return 0;
    384. } 
    385. //该函数设置图像尺寸大小,也就是所选格式的输出分辨率
    386. //UXGA:1600*1200,SVGA:800*600,CIF:352*288
    387. //width,height:图像宽度和图像高度
    388. //返回值:0,设置成功
    389. //    其他,设置失败
    390. u8 OV2640_ImageSize_Set(u16 width,u16 height)
    391. { 
    392. 	u8 temp; 
    393. 	SCCB_WR_Reg(0XFF,0X00);			
    394. 	SCCB_WR_Reg(0XE0,0X04);			
    395. 	SCCB_WR_Reg(0XC0,(width)>>3&0XFF);		//设置HSIZE的10:3位
    396. 	SCCB_WR_Reg(0XC1,(height)>>3&0XFF);		//设置VSIZE的10:3位
    397. 	temp=(width&0X07)<<3;
    398. 	temp|=height&0X07;
    399. 	temp|=(width>>4)&0X80; 
    400. 	SCCB_WR_Reg(0X8C,temp);	
    401. 	SCCB_WR_Reg(0XE0,0X00);				 
    402. 	return 0;
    403. }
    1. // main.c
    2. #include "sys.h"
    3. #include "delay.h"
    4. #include "usart.h"
    5. #include "led.h"
    6. #include "key.h"
    7. #include "usmart.h"  
    8. #include "usart2.h"  
    9. #include "timer.h" 
    10. #include "ov2640.h" 
    11. #include "dcmi.h" 
    12.  
    13.  
    14.  
    15.  
    16. u8 ov2640_mode=0;						//工作模式:0,RGB565模式;1,JPEG模式
    17.  
    18. #define jpeg_buf_size 31*1024  			//定义JPEG数据缓存jpeg_buf的大小(*4字节)
    19. __align(4) u32 jpeg_buf[jpeg_buf_size];	//JPEG数据缓存buf
    20. volatile u32 jpeg_data_len=0; 			//buf中的JPEG有效数据长度 
    21. volatile u8 jpeg_data_ok=0;				//JPEG数据采集完成标志 
    22. 										//0,数据没有采集完;
    23. 										//1,数据采集完了,但是还没处理;
    24. 										//2,数据已经处理完成了,可以开始下一帧接收
    25. //JPEG尺寸支持列表
    26. const u16 jpeg_img_size_tbl[][2]=
    27. {
    28. 	176,144,	//QCIF
    29. 	160,120,	//QQVGA
    30. 	352,288,	//CIF
    31. 	320,240,	//QVGA
    32. 	640,480,	//VGA
    33. 	800,600,	//SVGA
    34. 	1024,768,	//XGA
    35. 	1280,1024,	//SXGA
    36. 	1600,1200,	//UXGA
    37. }; 
    38. const u8*EFFECTS_TBL[7]={"Normal","Negative","B&W","Redish","Greenish","Bluish","Antique"};	//7种特效 
    39. const u8*JPEG_SIZE_TBL[9]={"QCIF","QQVGA","CIF","QVGA","VGA","SVGA","XGA","SXGA","UXGA"};	//JPEG图片 9种尺寸 
    40.  
    41.  
    42. //处理JPEG数据
    43. //当采集完一帧JPEG数据后,调用此函数,切换JPEG BUF.开始下一帧采集.
    44. void jpeg_data_process(void)
    45. {
    46. 	if(ov2640_mode)//只有在JPEG格式下,才需要做处理.
    47. 	{
    48. 		if(jpeg_data_ok==0)	//jpeg数据还未采集完?
    49. 		{	
    50. 			DMA_Cmd(DMA2_Stream1, DISABLE);//停止当前传输 
    51. 			while (DMA_GetCmdStatus(DMA2_Stream1) != DISABLE){}//等待DMA2_Stream1可配置  
    52. 			jpeg_data_len=jpeg_buf_size-DMA_GetCurrDataCounter(DMA2_Stream1);//得到此次数据传输的长度
    53. 				
    54. 			jpeg_data_ok=1; 				//标记JPEG数据采集完按成,等待其他函数处理
    55. 		}
    56. 		if(jpeg_data_ok==2)	//上一次的jpeg数据已经被处理了
    57. 		{
    58. 			DMA2_Stream1->NDTR=jpeg_buf_size;	
    59. 			DMA_SetCurrDataCounter(DMA2_Stream1,jpeg_buf_size);//传输长度为jpeg_buf_size*4字节
    60. 			DMA_Cmd(DMA2_Stream1, ENABLE);			//重新传输
    61. 			jpeg_data_ok=0;						//标记数据未采集
    62. 		}
    63. 	}
    64. } 
    65. //JPEG测试
    66. //JPEG数据,通过串口2发送给电脑.
    67. void jpeg_test(void)
    68. {
    69. 	u32 i; 
    70. 	u8 *p;
    71. 	u8 key;
    72. 	u8 effect=0,saturation=2,contrast=2;
    73. 	u8 size=8;		//默认是UXGA
    74. 	u8 msgbuf[15];	//消息缓存区 
    75. 	printf ("OV2640 JPEG Mode");
    76. 	printf ("\r\n\r\n");
    77. 	printf("KEY0:Contrast");			//对比度
    78. 	printf ("\r\n\r\n");
    79. 	printf("KEY1:Saturation"); 		//色彩饱和度
    80. 	printf ("\r\n\r\n");
    81. 	printf("KEY2:Effects"); 			//特效 
    82. 	printf ("\r\n\r\n");
    83. 	printf("KEY_UP:Size");				//分辨率设置 
    84. 	printf ("\r\n\r\n");
    85. 	sprintf((char*)msgbuf,"JPEG Size:%s",JPEG_SIZE_TBL[size]);
    86. 	printf ("%d",msgbuf);					//显示当前JPEG分辨率
    87. 	printf ("\r\n\r\n");
    88. 	
    89.  	OV2640_JPEG_Mode();		//JPEG模式
    90. 	My_DCMI_Init();			//DCMI配置
    91. 	DCMI_DMA_Init((u32)&jpeg_buf,jpeg_buf_size,DMA_MemoryDataSize_Word,DMA_MemoryInc_Enable);//DCMI DMA配置   
    92. 	OV2640_OutSize_Set(jpeg_img_size_tbl[size][0],jpeg_img_size_tbl[size][1]);//设置输出尺寸 
    93. 	DCMI_Start(); 		//启动传输
    94. 	while(1)
    95. 	{
    96. 		if(jpeg_data_ok==1)	//已经采集完一帧图像了
    97. 		{  
    98. 			p=(u8*)jpeg_buf;
    99. 			printf ("Sending JPEG data..."); //提示正在传输数据
    100. 			printf ("\r\n\r\n");
    101. 			for(i=0;i4;i++)		//dma传输1次等于4字节,所以乘以4.
    102. 			{
    103.         while(USART_GetFlagStatus(USART2,USART_FLAG_TC)==RESET);	//循环发送,直到发送完毕  		
    104. 				USART_SendData(USART2,p[i]); 
    105. 				key=KEY_Scan(0); 
    106. 				if(key)break;
    107. 			} 
    108. 			if(key)	//有按键按下,需要处理
    109. 			{  
    110. 				printf ("Quit Sending data   ");//提示退出数据传输
    111. 				switch(key)
    112. 				{				    
    113. 					case KEY0_PRES:	//对比度设置
    114. 						contrast++;
    115. 						if(contrast>4)contrast=0;
    116. 						OV2640_Contrast(contrast);
    117. 						sprintf((char*)msgbuf,"Contrast:%d",(signed char)contrast-2);
    118. 					printf ("\r\n\r\n");
    119. 						break;
    120. 					case KEY1_PRES:	//饱和度Saturation
    121. 						saturation++;
    122. 						if(saturation>4)saturation=0;
    123. 						OV2640_Color_Saturation(saturation);
    124. 						sprintf((char*)msgbuf,"Saturation:%d",(signed char)saturation-2);
    125. 					printf ("\r\n\r\n");
    126. 						break;
    127. 					case KEY2_PRES:	//特效设置				 
    128. 						effect++;
    129. 						if(effect>6)effect=0;
    130. 						OV2640_Special_Effects(effect);//设置特效
    131. 						sprintf((char*)msgbuf,"%s",EFFECTS_TBL[effect]);
    132. 					printf ("\r\n\r\n");
    133. 						break;
    134. 					case WKUP_PRES:	//JPEG输出尺寸设置   
    135. 						size++;  
    136. 						if(size>8)size=0;   
    137. 						OV2640_OutSize_Set(jpeg_img_size_tbl[size][0],jpeg_img_size_tbl[size][1]);//设置输出尺寸  
    138. 						sprintf((char*)msgbuf,"JPEG Size:%s",JPEG_SIZE_TBL[size]);
    139. 					printf ("\r\n\r\n");
    140. 						break;
    141. 				}
    142. 				printf ("%d",msgbuf);//显示提示内容
    143. 				printf ("\r\n\r\n");
    144. 				delay_ms(800); 				  
    145. 			}else printf ("Send data complete!!");//提示传输结束设置 
    146. 			jpeg_data_ok=2;	//标记jpeg数据处理完了,可以让DMA去采集下一帧了.
    147. 		}		
    148. 	}    
    149. } 
    150.  
    151. int main(void)
    152. { 
    153. 	u8 key;
    154. 	u8 t;
    155. 	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    156. 	delay_init(168);  //初始化延时函数
    157. 	uart_init(115200);		//初始化串口波特率为115200
    158. 	usart2_init(42,115200);		//初始化串口2波特率为115200
    159. 	LED_Init();					//初始化LED  
    160.  	KEY_Init();					//按键初始化 
    161. 	TIM3_Int_Init(10000-1,8400-1);//10Khz计数,1秒钟中断一次
    162. 	
    163.  	usmart_dev.init(84);		//初始化USMART  	 
    164. 	while(OV2640_Init())//初始化OV2640
    165. 	{
    166. 		printf ("OV2640 ERR");
    167. 		printf ("\r\n\r\n");
    168. 		delay_ms(200);
    169. 	}
    170. 	printf("OV2640 OK");  
    171. printf ("\r\n\r\n");	
    172. 	printf ("KEY0:RGB565  KEY1:JPEG");	
    173. 	printf ("\r\n\r\n");
    174.  	while(1)
    175. 	{	
    176.  
    177. 		key=KEY_Scan(0);
    178. 		if(key==KEY0_PRES)			//RGB565模式
    179. 		{
    180. 			ov2640_mode=0;   
    181. 			break;
    182. 		}else if(key==KEY1_PRES)	//JPEG模式
    183. 		{
    184. 			ov2640_mode=1;
    185. 			break;
    186. 		}
    187. 		t++; 									  
    188. 		delay_ms(5);	  
    189. 	}
    190. 	if(ov2640_mode)jpeg_test();
    191. //	else rgb565_test(); 
    192. }

    总结 

            OV2640摄像头的知识点比较的多，而且目前只有显示屏，所以不能在电脑端显示图像，后期串口线到了之后再补上。 

  • 相关阅读:
    flutter（学习日记篇-1）
    前端学习笔记 第1集：WebStorm 安装、vue3.0 安装、npm安装
    自然语言处理的多行业应用
    day54 django中orm数据库增删改查
    【SQL】mysql创建定时任务执行存储过程--20230928
    5年经验之谈 —— 性能测试如何定位分析性能瓶颈？
    Linux进程通信——IPC、管道、FIFO的引入
    Docker简易部署RabbitMQ集群、分布式事务解决方案+案例(可靠生产、可靠消费)
    Python与数据分析--每天绘制Matplotlib库实例图片3张-第1天
    小红书如何打造爆款内容？
  • 原文地址：https://blog.csdn.net/weixin_66578482/article/details/126805878