• cubeIDE开发，在LCD显示摄像头抓取的图片数据

    目录

    一、摄像头相关资料信息

    二、 基于旧(.ioc)创建新工程

      三、配置与Camera相关的MCU引脚

    四、Camera源码设计

             1、gc0329 型号芯片数据手册分析

      2.程序代码设计

    五、编辑及测试

    一、摄像头相关资料信息

            在LCD上显示当前camera的图像数据，类似我们前面提到的LCD显示图片数据，就是实时将摄像头抓取的视频数据帧（图片）转换成图片字码表，即LCD宽*LCD高像素大小的颜色点阵，然后推送到LCD接口实现刷新显示。

            本博文使用的是STM32L496VGT3开发板进行测试，该开发板自带了Camera摄像头，采用DCMI 接口与MCU通信，Camera 是由深圳影领电子有限公司提供的 YL-F170066-0329.采用的是 8bits 数据接口，通过 24Pin BTB 连接器外接一个 Camera 模组。Camera 配置通过 I2C3 接入 MCU，地址为 0x78/0x79。BTB 连接器的接口定义如下表：

             即对于Camera 下行指令是采用I2C通信，视频数据推送给MCU采用的是DCMI 通信。Camera 的硬件原理框图如下：

             各个引脚相关参数：

    二、 基于旧(.ioc)创建新工程

            本文基于本专栏前面的LCD显示图片博文上进行创建新工程，并将其源码移植到新工程，然后在此基础上进行Camera相关配置及源码实现。

            cubeIDE开发，结合图片取模工具，stm32程序在LCD显示图片_py_free的博客-CSDN博客

            【1】在CubeIDE工作空间，创建一个stm32L496VGTx_cam的目录文件，将前面LCD显示图片工程的(stm32L496VGTx_lcm.ioc)拷贝到该目录下，并改名为stm32L496VGTx_cam.ioc.

            【2】打开cubeIDE开发工具，选择Create a New STM32 Project from an Existing STM32CubeMX Configuration File(.ioc)新建一个工程

             【2】选择刚刚拷贝并修改了名字的(.ioc)文件，在工程配置属性页面中，将工程名称及工程存放路径设置为刚刚新建文件夹的路径，完成工程创建。

             【4】创建工程后，在工程目录下新建一个ICore源文件夹，将原来stm32L496VGTx_lcm工程的ICore源码文件目录拷贝覆盖该文件夹。同时，也可将原来工程有过调整的spi.c和main.c文件拷贝覆盖到新工程文件中，同样，禁止syscalls.c编译。设置项目编译输出支持bin和hex格式。

             然后点击编译，成功通过编译，妥妥的是上次博文中实现的工程，只是更换了个工程名字而已。

      三、配置与Camera相关的MCU引脚

            在成功移植LCD显示图片工程后，双击stm32L496VGTx_cam.ioc打开cubeMX编辑界面，按上述的引脚要求配置MCU与Camera相关引脚。

            【1】开启I2C3的功能，参数保持默认设置即可

             I2C3的引脚相关配置如下：

            【2】开启DCMI功能 ，参数设置如下。

             添加DCMI的DMA功能支持

             并开启DCMI的终端功能支持

             DCMI相关引脚配置如下：

             【3】开启Camera辅助功能的GPIO引脚接口（PB8、PE13配置，与上面开发板给出的引脚参数资料不同）

             PA8引脚配置

             完成配置后点击保存输出生成代码。

    四、Camera源码设计

            在ICore中添加一个cam目录，并在该目录下创建Camera.h和Camera.c源文件。图形编辑配置界面生成代码及手动添加代码结构如下。

             1、gc0329 型号芯片数据手册分析

            本Camera模组的MCU芯片是gc0329 型号芯片，我在网上查阅该型号的数据手册及逐项分析如下：

            【1】Camera模组参数从设备地址0X62/3，非开发板指出的0x78/0x79

             gc0329芯片支持I2C接口控制信号设计如下：

             PWDN 与 RESET 均是异步设计，生效时不需要 MCLK pin 有时钟提供。PWDN 高有效，Low -> 正常工作，High -> 省电模式；RESET 低有效，Low -> reset 芯片，High -> 正常工作

            设帧同步信号 Vsync 低有效，行同步 Hsync 为高有效，而图像输出格式为 YCbCr 或 RGB565。例如我们在LCD显示图像时，图片转换工具了设置16位真彩的RGB565格式一样。

             GC0329 采用逐行扫描的方式将阵列产生的信号依次输入到模拟信号处理模块中。最开始的
    行为 0 行。在默认寄存器设置下，Sensor 的阵列数据输出顺序为从下到上，从左到右。图像扫描的方式输出设置地址为0X17。


            【2】模拟转换地址（analog PWC）0XFC，将寄存器 0xfc[0]置 1，0xf0 写为 0x00。此方式同样降低功耗，输出 pin 高阻，寄存器值保持不变。此时寄存器是可以读写的。要恢复 normal 工作模式，需要将 0xfc[0]置 0，0xf0 写为 0xff。芯片内部寄存器复位默认值有两种方式：1) RESET pin 接入低电平；2) 将寄存器 0xfe[7]置 1。      

            更多输出使能控制。

    1. VSync output enable  0xf0[0]         控制 VSYNC pin 输出
    2.                                      0 –> VSYNC pin 高阻
    3.                                      1 –> VSYNC pin 正常输出
    4.     
    5. HSync output enable  0xf0[1]         控制 HSYNC pin 输出
    6.                                      0 –> HSYNC pin 高阻
    7.                                      1 –> HSYNC pin 正常输出
    8.  
    9. PCLK output enable  0xf0[2]         控制 PCLK pin 输出
    10.                                     0 –> PCLK pin 高阻
    11.                                     1 –> PCLK pin 正常输出
    12.  
    13. Pixel data[7:0] output enable 0xf0[3]   控制 data pin 输出
    14.                                         0 –> data pin 高阻
    15.                                         1 –> data pin 正常输出

            寄存器相关信息，设备ID存储地址为0X00。page 选择由 P0:0xfe[1:0]设置，设为 0x00 表示page0，设为 0x01 表示 page1 。

            【3】输出PIN驱动能力，PCLK PIN 、Data PIN、SYNC PIN的设置

             【4】时钟预分频，外部 MCLK 时钟输入后，通过 clock divider 模块对 MCLK 进行分频，芯片内部工作频率基于分频后的频率。

             【5】同步模式设置，VSYNC 为场同步信号，HSYNC 为行同步信号，PCLK 为输出 data 的同步时钟，可以通过寄存器0X46来控制这三个信号的极性。

             【6】GC0329 可以截取任意尺寸（≤VGA）的窗口输出，且有两种模式实现窗口输出，这两种模式输出小于 VGA 窗口时，视角均会变小。

             Windowing 模式，用 column start 和 row start 来分别确定要挖窗口起始的 X/Y 坐标，用 window width-8 和 window height-8（注意寄存器设置要比实际输出多 8）来确定所需要窗口的宽度和高度。

            Crop window 模式，用 Out window x0 和 Out window y0 来分别确定要挖窗口
    起始的 X/Y 坐标，用 Out window width 和 Out window height 来确定所需要窗口的宽度和
    高度。

            subsample 模式，如果要实现视角不变输出 QVGA/QQVGA/CIF/QCIF等窗口，需要用到 subsample 模式，在 windowing（0x09-0x10 寄存器）确定好图像窗口尺寸后，采用抽点的
    方式输出更小尺寸的数据，最终输出图像尺寸的行/列可以为设定窗口行/列的 1/2, 1/3, 1/4,
    1/5, 1/6, 1/7（表示行为原始尺寸的 1/7，列也为原始尺寸的 1/7），同时也能实现 3/5，2/3，
    4/7 等采样率。例如下图设置示例（P0:0x5a 表示 0x5a 寄存器是 page0 的）。

             【7】在 GC0329 中，消除灯管频率导致的 flicker 问题，需要同时配置 exposure step register（P1:0x03,P1；0x04）Hb（{P0:0x05，P0:0x06}），Vb（{P0:0x07，P0:0x08}），exp_level(P1:0x2b~0x32)来实现。消除 flicker 的原理即是曝光时间是灯管周期的整数倍。
    计算方法为： step * row_time = N * T。

             可以配置 4 档 Exp_level，用户可以通过修改 P1:0x33[5:4]来设置用哪一档 exp_level（范围为 0-3），设置完成后，AEC 最大曝光时间只能达到 exp_level 所设定的值，从而达到控制帧率的目的。Exp_level 的配置只要用是所计算出来的 step 的整数倍即可，可按照想要的帧率配置，每个 level 需要配两个寄存器，如 0xe4[3:0]为高位，0xe5 为低位。

             【8】输出模式设置

            YUV/RGB565 输出设置及RawRGB 输出设置：

             自动曝光控制（Auto Exposure Control）设置

    1. Function           Address         Value     Description
    2. AEC enable         P0:0x4f[0]      1’b0      使能 AEC 模块
    3. Target Y           P1:0x13         0x50      AEC 目标亮度值
    4. AEC action period  P1:0x11[6:4]    2’b3      AEC 每隔几帧调一次
    5. Exp level          P1:0x2b-0x32    --        配置曝光等级，具体见 4.6.2
    6. Max exp level      P1:0x33[5:4]    --        选择曝光等级 0~3 中的一档
    7. Exp min            P1:0x34         0x04      设置 AEC 自动调节的最小值
    8. Auto pre gain      P0:0x71         --        AEC 使能时，为只读。
    9. Auto post gain     P0:0x72         --        AEC 不使能时，可读写。
    10. Pre gain limit     P1:0x22         0x40      Auto_pre_gain 的最大值。
    11. Post gain limit    P1:0x21         0x80      Auto_post_gain 的最大值。

             自动白平衡（Auto White Balance）设置

    1. Function         Address         Value         Description
    2. AWB enable       P0:0x42[1]      1’b0          使能 AWB 模块
    3. AWB_R_gain       P0:0x77         --            AWB 使能时，为只读。
    4.                                                AWB 不使能时，可读写。
    5. AWB_G_gain       P0:0x78         --
    6. AWB_B_gain       P0:0x79         --
    7. AWB_R_gain_limit P1:0x67         0x80          AWB 中 R 通道的增益限制
    8. AWB_G_gain_limit P1:0x68         0x80          AWB 中 G 通道的增益限制
    9. AWB_B_gain_limit P1:0x69         0x80          AWB 中 B 通道的增益限制
    10. AWB action period P1: 0x5d[5:4]  1’b0          AWB 每隔几帧调一次。
    11. R_ratio          P0:0x7a         0x80         做完 AWB 后 R 通道所乘的增益，0x80 为 1 倍增益。
    12. G_ratio          P0:0x7b         0x80         做完 AWB 后 R 通道所乘的增益，0x80 为 1 倍增益。
    13. B_ratio          P0:0x7c         0x80         做完 AWB 后 B 通道所乘的增益，0x80 为 1 倍增益。

            以及镜头阴影补偿（Lens Shading Compensation）、去坏点（Delete defective points）、去噪（Denoise）、边缘加强（Edge Enhancement）、饱和度、对比度、特效参数、Gamma 调整、色彩矩阵（Color Matrix）等摄像头图像输出相关设置就不逐一列举。

      2.程序代码设计

            【1】伪代码实现设计

    1. 从机地址：0X62/0X63
    2. Init
    3. 拉低CAM_PD，拉高CAM_RST
    4. 向 0xfe 写入 设置值
    5. 向 0xfc 写入 设置值
    6. 向 0x00 读取 CHIPID 验证是否==0XC0
    7. 进行 摄像头参数设置：
    8. （analog、blk、ISP、DNDD、INTPEE、ASDE、RGB-gamma、Y-gamma、YCP、AEC、ABS、AWB、LSC、flicker、输出等）
    9. 进行 LCD显示输出配置（VGA-DCMI）
    10. 启动DCMI抓取数据及写入DMA
    11.  
    12. 刷新显示
    13. DCMI回调，调用LCD显示函数进行屏幕刷新显示

            【2】依据上述分析及伪代码设计，给出camera.h和camera.c源码

    1. #ifndef __GC0329_H
    2. #define __GC0329_H
    3. #include "main.h"
    4. #include "dcmi.h"
    5. #include "i2c.h"
    6. #include "gpio.h"
    7. #include "../oled/oled.h"
    8.  
    9. #define  GC0329_I2CADDR 0X62
    10. #define  GC0329_ID    	0xC0
    11. #define  GC0329_CHIPID  0x00
    12.  
    13. /* GC0329 Registers definition */
    14. #define GC0329_SENSOR_PIDH              0x00
    15. #define GC0329_SENSOR_PIDL              0x0B
    16. #define GC0329_SENSOR_COM7              0x12
    17. #define GC0329_SENSOR_TSLB              0x3A
    18. #define GC0329_SENSOR_MTX1              0x4F
    19. #define GC0329_SENSOR_MTX2              0x50
    20. #define GC0329_SENSOR_MTX3              0x51
    21. #define GC0329_SENSOR_MTX4              0x52
    22. #define GC0329_SENSOR_MTX5              0x53
    23. #define GC0329_SENSOR_MTX6              0x54
    24. #define GC0329_SENSOR_BRTN              0x55
    25. #define GC0329_SENSOR_CNST1             0x56
    26. #define GC0329_SENSOR_CNST2             0x57
    27.  
    28. /**
    29.  * @brief  GC0329 Features Parameters
    30.  */
    31. #define GC0329_BRIGHTNESS_LEVEL0        0xB0     /* Brightness level -2         */
    32. #define GC0329_BRIGHTNESS_LEVEL1        0x98     /* Brightness level -1         */
    33. #define GC0329_BRIGHTNESS_LEVEL2        0x00     /* Brightness level 0          */
    34. #define GC0329_BRIGHTNESS_LEVEL3        0x18     /* Brightness level +1         */
    35. #define GC0329_BRIGHTNESS_LEVEL4        0x30     /* Brightness level +2         */
    36.  
    37. #define GC0329_BLACK_WHITE_BW           0xCC000000000000  /* Black and white effect      */
    38. #define GC0329_BLACK_WHITE_NEGATIVE     0xEC808000008080  /* Negative effect             */
    39. #define GC0329_BLACK_WHITE_BW_NEGATIVE  0xEC000000000000  /* BW and Negative effect      */
    40. #define GC0329_BLACK_WHITE_NORMAL       0xCC808000008080  /* Normal effect               */
    41.  
    42. #define GC0329_CONTRAST_LEVEL0          0x30     /* Contrast level -2           */
    43. #define GC0329_CONTRAST_LEVEL1          0x38     /* Contrast level -1           */
    44. #define GC0329_CONTRAST_LEVEL2          0x40     /* Contrast level 0            */
    45. #define GC0329_CONTRAST_LEVEL3          0x50     /* Contrast level +1           */
    46. #define GC0329_CONTRAST_LEVEL4          0x60     /* Contrast level +2           */
    47.  
    48. #define GC0329_COLOR_EFFECT_NONE        0xCC808000008080  /* No color effect             */
    49. #define GC0329_COLOR_EFFECT_ANTIQUE     0xCC000020F00000  /* Antique effect              */
    50. #define GC0329_COLOR_EFFECT_BLUE        0xCC000000000060  /* Blue effect                 */
    51. #define GC0329_COLOR_EFFECT_GREEN       0xCC000000008000  /* Green effect                */
    52. #define GC0329_COLOR_EFFECT_RED         0xCC600000000000  /* Red effect                  */
    53.  
    54. #define CAMERA_R160x120                 0x00   /* QQVGA Resolution                     */
    55. #define CAMERA_R320x240                 0x01   /* QVGA Resolution                      */
    56. #define CAMERA_R480x272                 0x02   /* 480x272 Resolution                   */
    57. #define CAMERA_R640x480                 0x03   /* VGA Resolution                       */
    58.  
    59. #define CAMERA_CONTRAST_BRIGHTNESS      0x00   /* Camera contrast brightness features  */
    60. #define CAMERA_BLACK_WHITE              0x01   /* Camera black white feature           */
    61. #define CAMERA_COLOR_EFFECT             0x03   /* Camera color effect feature          */
    62.  
    63. #define CAMERA_BRIGHTNESS_LEVEL0        0x00   /* Brightness level -2         */
    64. #define CAMERA_BRIGHTNESS_LEVEL1        0x01   /* Brightness level -1         */
    65. #define CAMERA_BRIGHTNESS_LEVEL2        0x02   /* Brightness level 0          */
    66. #define CAMERA_BRIGHTNESS_LEVEL3        0x03   /* Brightness level +1         */
    67. #define CAMERA_BRIGHTNESS_LEVEL4        0x04   /* Brightness level +2         */
    68.  
    69. #define CAMERA_CONTRAST_LEVEL0          0x05   /* Contrast level -2           */
    70. #define CAMERA_CONTRAST_LEVEL1          0x06   /* Contrast level -1           */
    71. #define CAMERA_CONTRAST_LEVEL2          0x07   /* Contrast level  0           */
    72. #define CAMERA_CONTRAST_LEVEL3          0x08   /* Contrast level +1           */
    73. #define CAMERA_CONTRAST_LEVEL4          0x09   /* Contrast level +2           */
    74.  
    75. #define CAMERA_BLACK_WHITE_BW           0x00   /* Black and white effect      */
    76. #define CAMERA_BLACK_WHITE_NEGATIVE     0x01   /* Negative effect             */
    77. #define CAMERA_BLACK_WHITE_BW_NEGATIVE  0x02   /* BW and Negative effect      */
    78. #define CAMERA_BLACK_WHITE_NORMAL       0x03   /* Normal effect               */
    79.  
    80. #define CAMERA_COLOR_EFFECT_NONE        0x00   /* No effects                  */
    81. #define CAMERA_COLOR_EFFECT_BLUE        0x01   /* Blue effect                 */
    82. #define CAMERA_COLOR_EFFECT_GREEN       0x02   /* Green effect                */
    83. #define CAMERA_COLOR_EFFECT_RED         0x03   /* Red effect                  */
    84. #define CAMERA_COLOR_EFFECT_ANTIQUE     0x04   /* Antique effect              */
    85.  
    86. /**
    87.   * @}
    88.   */
    89.  
    90. typedef struct
    91. {
    92.     void     (*Init)(uint16_t, uint32_t);
    93.     uint16_t (*ReadID)(uint16_t);
    94.     void     (*Config)(uint16_t, uint32_t, uint32_t, uint32_t);
    95. } CAMERA_DrvTypeDef;
    96.  
    97. //void gc0329_mclk_onoff(int on);
    98. void gc0329_power_onoff(int on);
    99. void gc0329_Init(uint16_t DeviceAddr, uint32_t resolution);
    100. void gc0329_Config(uint16_t DeviceAddr, uint32_t feature, uint32_t value, uint32_t BR_value);
    101. uint16_t gc0329_ReadID(uint16_t dummy);
    102. uint64_t gc0329_ConvertValue(uint32_t feature, uint32_t value);
    103.  
    104. /* CAMERA driver structure */
    105. extern CAMERA_DrvTypeDef   gc0329_drv;
    106. extern DCMI_HandleTypeDef hdcmi;
    107.  
    108. void enable_camera_display(uint8_t on);
    109. void CAMERA_Init(uint32_t Resolution);
    110. void CameraDEMO_Init();
    111. void enable_camera_display(uint8_t on);
    112. int CameraHAL_Capture_Start(uint8_t * buf, uint32_t len, void(*notify)());
    113. #endif //__GC0329_H

            camera.c

    1. #include "camera.h"
    2. #include 
    3. #include 
    4.  
    5. extern I2C_HandleTypeDef hi2c3;
    6. CAMERA_DrvTypeDef *camera_drv;
    7. DCMI_HandleTypeDef *phdcmi;
    8. uint16_t *camera_buff = NULL;
    9. static void(*pCapFunc)() = 0;
    10.  
    11. CAMERA_DrvTypeDef   gc0329_drv =
    12. {
    13.     gc0329_Init,
    14.     gc0329_ReadID,
    15.     gc0329_Config,
    16. };
    17.  
    18. /* Initialization sequence for VGA resolution (640x480)*/
    19. const unsigned char GC0329_VGA[][2] =
    20. {
    21.     {0xfe, 0x80},
    22.     {0xfc, 0x16},
    23.     {0xfc, 0x16},
    24.     {0xfe, 0x00},
    25.  
    26.     {0xfa, 0x00},
    27.  
    28.     {0x70, 0x48},
    29.     {0x73, 0x90},
    30.     {0x74, 0x80},
    31.     {0x75, 0x80},
    32.     {0x76, 0x94},  //80 jambo
    33.     {0x77, 0x62},
    34.     {0x78, 0x47},
    35.     {0x79, 0x40},
    36.  
    37.     {0x03, 0x02},
    38.     {0x04, 0x40},
    39.  
    40.     analog
    41.     {0xfc, 0x16},
    42.     {0x09, 0x00},
    43.     {0x0a, 0x02},
    44.     {0x0b, 0x00},
    45.     {0x0c, 0x02},
    46.     #ifndef CAMERA_GRAY_MIRROR
    47.     {0x17, 0x15},  //0x14
    48.     #endif
    49.     {0x19, 0x05},
    50.     {0x1b, 0x24},
    51.     {0x1c, 0x04},
    52.     {0x1e, 0x08},
    53.     {0x1f, 0x08},  //C8
    54.     {0x20, 0x01},
    55.     {0x21, 0x48},
    56.     {0x22, 0xba},
    57.     {0x23, 0x22},
    58.     {0x24, 0x16},
    59.  
    60.     blk
    61.     added for MID
    62.     {0x26, 0xf4},  //BLK
    63.     {0x2a, 0x2c},
    64.     {0x2b, 0x2c},
    65.     {0x2c, 0x2c},
    66.     {0x2d, 0x2c},
    67.  
    68.     {0x26, 0xf7},  //BLK
    69.     {0x28, 0x7f},  //BLK limit
    70.     {0x29, 0x00},
    71.     {0x32, 0x00},  //04 darkc
    72.     {0x33, 0x20},  //blk ratio
    73.     {0x34, 0x20},
    74.     {0x35, 0x20},
    75.     {0x36, 0x20},
    76.  
    77.     {0x3b, 0x04},  //manual offset
    78.     {0x3c, 0x04},
    79.     {0x3d, 0x04},
    80.     {0x3e, 0x04},
    81.  
    82.     ISP BLOCK ENABLE
    83.     {0x40, 0xff},
    84.     {0x41, 0x24}, //[5]skin detection
    85.     {0x42, 0xfa}, //disable ABS
    86.     {0x46, 0x03},
    87.     {0x4b, 0xca},
    88.     {0x4d, 0x01},
    89.     {0x4f, 0x01},
    90.     {0x70, 0x48},
    91.  
    92.     DNDD
    93.     {0x80, 0x07},  // 0xe7 20140915
    94.     {0x81, 0xc2},  // 0x22 20140915
    95.     {0x82, 0x90},  //DN auto DNDD DEC DNDD //0e //55 jambo
    96.     {0x83, 0x05},
    97.     {0x87, 0x40},  // 0x4a  20140915
    98.  
    99.     INTPEE
    100.     {0x90, 0x8c},  //ac
    101.     {0x92, 0x05},
    102.     {0x94, 0x05},
    103.     {0x95, 0x45},  //0x44
    104.     {0x96, 0x88},
    105.  
    106.     ASDE
    107.     {0xfe, 0x01},
    108.     {0x18, 0x22},
    109.     {0xfe, 0x00},
    110.     {0x9c, 0x0a},
    111.     {0xa0, 0xaf},
    112.     {0xa2, 0xff},
    113.     {0xa4, 0x30},  //50 jambo
    114.     {0xa5, 0x31},
    115.     {0xa7, 0x35},
    116.  
    117.     RGB gamma
    118.     {0xfe, 0x00},
    119.     {0xbf, 0x0b},
    120.     {0xc0, 0x1d},
    121.     {0xc1, 0x33},
    122.     {0xc2, 0x49},
    123.     {0xc3, 0x5d},
    124.     {0xc4, 0x6e},
    125.     {0xc5, 0x7c},
    126.     {0xc6, 0x99},
    127.     {0xc7, 0xaf},
    128.     {0xc8, 0xc2},
    129.     {0xc9, 0xd0},
    130.     {0xca, 0xda},
    131.     {0xcb, 0xe2},
    132.     {0xcc, 0xe7},
    133.     {0xcd, 0xf0},
    134.     {0xce, 0xf7},
    135.     {0xcf, 0xff},
    136.  
    137.     Y gamma
    138.     {0xfe, 0x00},
    139.     {0x63, 0x00},
    140.     {0x64, 0x06},
    141.     {0x65, 0x0d},
    142.     {0x66, 0x1b},
    143.     {0x67, 0x2b},
    144.     {0x68, 0x3d},
    145.     {0x69, 0x50},
    146.     {0x6a, 0x60},
    147.     {0x6b, 0x80},
    148.     {0x6c, 0xa0},
    149.     {0x6d, 0xc0},
    150.     {0x6e, 0xe0},
    151.     {0x6f, 0xff},
    152.  
    153.     //CC///
    154.     #if 1 //main
    155.     {0xfe, 0x00},
    156.     {0xb3, 0x44},
    157.     {0xb4, 0xfd},
    158.     {0xb5, 0x02},
    159.     {0xb6, 0xfa},
    160.     {0xb7, 0x48},
    161.     {0xb8, 0xf0},
    162.     #else //sub
    163.     {0xfe, 0x00},
    164.     {0xb3, 0x42}, //40
    165.     {0xb4, 0xff}, //00
    166.     {0xb5, 0x06}, //06
    167.     {0xb6, 0xf0}, //00
    168.     {0xb7, 0x44}, //40
    169.     {0xb8, 0xf0}, //00
    170.     #endif
    171.  
    172.     // crop
    173.     {0x50, 0x01},
    174.     YCP
    175.     {0xfe, 0x00},
    176.  
    177.     {0xd0, 0x40},
    178.     {0xd1, 0x28},
    179.     {0xd2, 0x28},
    180.  
    181.     {0xd3, 0x40},  //cont 0x40
    182.     {0xd5, 0x00},
    183.  
    184.     {0xdd, 0x14},
    185.     {0xde, 0x34},
    186.  
    187.     AEC
    188.     {0xfe, 0x01},
    189.     {0x10, 0x40},  // before Gamma
    190.     {0x11, 0x21},  //
    191.     {0x12, 0x13},	// center weight *2
    192.     {0x13, 0x50},  //4 //4}, // AE Target
    193.     #ifdef CAMERA_GRAY_MIRROR
    194.     {0x17, 0xa9},	//88, 08, c8, a8
    195.     #else
    196.     {0x17, 0xa8},	//88, 08, c8, a8
    197.     #endif
    198.     {0x1a, 0x21},
    199.     {0x20, 0x31},	//AEC stop margin
    200.     {0x21, 0xc0},
    201.     {0x22, 0x60},
    202.     {0x3c, 0x50},
    203.     {0x3d, 0x40},
    204.     {0x3e, 0x45},  //read 3f for status
    205.  
    206. //main
    207.     {0xfe, 0x01},
    208.     {0x06, 0x12},
    209.     {0x07, 0x06},
    210.     {0x08, 0x9c},
    211.     {0x09, 0xee},
    212.     {0x50, 0xfc},
    213.     {0x51, 0x28},
    214.     {0x52, 0x10},
    215.     {0x53, 0x20},
    216.     {0x54, 0x12},
    217.     {0x55, 0x16},
    218.     {0x56, 0x30},
    219.     {0x58, 0x60},
    220.     {0x59, 0x08},
    221.     {0x5a, 0x02},
    222.     {0x5b, 0x63},
    223.     {0x5c, 0x35},
    224.     {0x5d, 0x72},
    225.     {0x5e, 0x11},
    226.     {0x5f, 0x40},
    227.     {0x60, 0x40},
    228.     {0x61, 0xc8},
    229.     {0x62, 0xa0},
    230.     {0x63, 0x40},
    231.     {0x64, 0x50},
    232.     {0x65, 0x98},
    233.     {0x66, 0xfa},
    234.     {0x67, 0x80},
    235.     {0x68, 0x60},
    236.     {0x69, 0x90},
    237.     {0x6a, 0x40},
    238.     {0x6b, 0x39},
    239.     {0x6c, 0x30},
    240.     {0x6d, 0x60},
    241.     {0x6e, 0x41},
    242.     {0x70, 0x10},
    243.     {0x71, 0x00},
    244.     {0x72, 0x10},
    245.     {0x73, 0x40},
    246.     {0x80, 0x60},
    247.     {0x81, 0x50},
    248.     {0x82, 0x42},
    249.     {0x83, 0x40},
    250.     {0x84, 0x40},
    251.     {0x85, 0x40},
    252.     {0x74, 0x40},
    253.     {0x75, 0x58},
    254.     {0x76, 0x24},
    255.     {0x77, 0x40},
    256.     {0x78, 0x20},
    257.     {0x79, 0x60},
    258.     {0x7a, 0x58},
    259.     {0x7b, 0x20},
    260.     {0x7c, 0x30},
    261.     {0x7d, 0x35},
    262.     {0x7e, 0x10},
    263.     {0x7f, 0x08},
    264.  
    265.     ///ABS///
    266.     {0x9c, 0x00},
    267.     {0x9e, 0xc0},
    268.     {0x9f, 0x40},
    269.  
    270.     CC-AWB
    271.     {0xd0, 0x00},
    272.     {0xd2, 0x2c},
    273.     {0xd3, 0x80},
    274.  
    275.     ///LSC //
    276.  
    277.     {0xfe, 0x01},
    278.     {0xc0, 0x0b},
    279.     {0xc1, 0x07},
    280.     {0xc2, 0x05},
    281.     {0xc6, 0x0b},
    282.     {0xc7, 0x07},
    283.     {0xc8, 0x05},
    284.     {0xba, 0x39},
    285.     {0xbb, 0x24},
    286.     {0xbc, 0x23},
    287.     {0xb4, 0x39},
    288.     {0xb5, 0x24},
    289.     {0xb6, 0x23},
    290.     {0xc3, 0x00},
    291.     {0xc4, 0x00},
    292.     {0xc5, 0x00},
    293.     {0xc9, 0x00},
    294.     {0xca, 0x00},
    295.     {0xcb, 0x00},
    296.     {0xbd, 0x2b},
    297.     {0xbe, 0x00},
    298.     {0xbf, 0x00},
    299.     {0xb7, 0x09},
    300.     {0xb8, 0x00},
    301.     {0xb9, 0x00},
    302.     {0xa8, 0x31},
    303.     {0xa9, 0x23},
    304.     {0xaa, 0x20},
    305.     {0xab, 0x31},
    306.     {0xac, 0x23},
    307.     {0xad, 0x20},
    308.     {0xae, 0x31},
    309.     {0xaf, 0x23},
    310.     {0xb0, 0x20},
    311.     {0xb1, 0x31},
    312.     {0xb2, 0x23},
    313.     {0xb3, 0x20},
    314.     {0xa4, 0x00},
    315.     {0xa5, 0x00},
    316.     {0xa6, 0x00},
    317.     {0xa7, 0x00},
    318.     {0xa1, 0x3c},
    319.     {0xa2, 0x50},
    320.     {0xfe, 0x00},
    321.  
    322.      flicker ///
    323.  
    324.     {0x05, 0x02},
    325.     {0x06, 0x2c},
    326.     {0x07, 0x00},
    327.     {0x08, 0xb8},
    328.  
    329.     {0xfe, 0x01},
    330.     {0x29, 0x00},	//anti-flicker step [11:8]
    331.     {0x2a, 0x60},	//anti-flicker step [7:0]
    332.  
    333.     {0x2b, 0x02},	//exp level 0  14.28fps
    334.     {0x2c, 0xa0},
    335.     {0x2d, 0x03},	//exp level 1  12.50fps
    336.     {0x2e, 0x00},
    337.     {0x2f, 0x03},	//exp level 2  10.00fps
    338.     {0x30, 0xc0},
    339.     {0x31, 0x05},	//exp level 3  7.14fps
    340.     {0x32, 0x40},
    341.     {0x33, 0x20},
    342.     {0xfe, 0x00},
    343.  
    344. out ///
    345.     #ifdef CAMERA_GRAY_MIRROR
    346.     {0x44, 0xB1},
    347.     #else
    348.     {0x44, 0xA6},
    349.     #endif
    350.     {0xf0, 0x07},
    351.     {0xf1, 0x01},
    352. };
    353.  
    354. /* Initialization sequence for QVGA resolution (320x240) */
    355. const unsigned char GC0329_QVGA[][2] =
    356. {
    357.     {0xff, 0xff},
    358. };
    359.  
    360. /* Initialization sequence for QQVGA resolution (160x120) */
    361. const char GC0329_QQVGA[][2] =
    362. {
    363.     {0xff, 0xff},
    364. };
    365.  
    366. //void gc0329_mclk_onoff(int on)
    367. //{
    368. //    RCC_OscInitTypeDef RCC_OscInitStruct;
    369. //
    370. //    /*xiehj add RCC_OSCILLATORTYPE_HSI48*/
    371. //    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI48;
    372. //
    373. //    /*xiehj add*/
    374. //    if(on)
    375. //        RCC_OscInitStruct.HSI48State = RCC_HSI48_ON;
    376. //    else
    377. //        RCC_OscInitStruct.HSI48State = RCC_HSI48_OFF;
    378. //
    379. //    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    380. //    {
    381. //
    382. //    }
    383. //}
    384.  
    385. void gc0329_power_onoff(int on)
    386. {
    387.     if(1 == on)
    388.     {
    389.         HAL_GPIO_WritePin(CAM_PD_GPIO_Port, CAM_PD_Pin, GPIO_PIN_RESET);
    390.         HAL_Delay(10);
    391. 		HAL_GPIO_WritePin(CAM_RST_GPIO_Port, CAM_RST_Pin, GPIO_PIN_RESET);
    392. 		HAL_Delay(50);
    393. 	  	HAL_GPIO_WritePin(CAM_RST_GPIO_Port, CAM_RST_Pin, GPIO_PIN_SET);
    394.     }
    395.     else
    396.     {
    397.         HAL_GPIO_WritePin(CAM_RST_GPIO_Port, CAM_RST_Pin, GPIO_PIN_RESET);
    398. 		HAL_Delay(50);
    399. 		HAL_GPIO_WritePin(CAM_PD_GPIO_Port, CAM_PD_Pin, GPIO_PIN_SET);
    400.     }
    401. }
    402.  
    403. uint8_t CAMERA_IO_Read(uint8_t DevAddr, uint8_t Reg)
    404. {
    405.     uint8_t read_value = 0;
    406.     HAL_StatusTypeDef i2c3_status = 0X00;
    407. //    i2c3_status = HAL_I2C_Mem_Read_IT(&hi2c3, DevAddr, Reg, I2C_MEMADD_SIZE_8BIT, (uint8_t *)&read_value, 1);
    408.     i2c3_status = HAL_I2C_Mem_Read(&hi2c3, DevAddr, Reg, I2C_MEMADD_SIZE_8BIT, (uint8_t *)&read_value, 1, 1000);
    409.     if(HAL_OK != i2c3_status)
    410.     {
    411.   	  printf("[1]CAMERA_IO_Read error HAL_StatusTypeDef(0x%02x) ErrorCode(%lu) State(%u) \r\n"
    412.   			  ,i2c3_status,hi2c3.ErrorCode,hi2c3.State);
    413.         return read_value ;
    414.     }
    415.     return read_value;
    416. }
    417.  
    418. uint8_t CAMERA_IO_Write(uint8_t DevAddr, uint8_t Reg, uint8_t Value)
    419. {
    420. 	HAL_StatusTypeDef i2c3_status = 0X00;
    421. //	i2c3_status = HAL_I2C_Mem_Write_IT(&hi2c3, DevAddr, Reg, I2C_MEMADD_SIZE_8BIT, (uint8_t *)&Value, 1);
    422. 	i2c3_status = HAL_I2C_Mem_Write(&hi2c3, DevAddr, Reg, I2C_MEMADD_SIZE_8BIT, (uint8_t *)&Value, 1, 1000);
    423.     if(HAL_OK != i2c3_status)
    424.     {
    425.     	printf("1)CAMERA_IO_Write error HAL_StatusTypeDef(0x%02x) hi2c3.ErrorCode(%lu) hi2c3.State(%u)\r\n"
    426.     					,i2c3_status,hi2c3.ErrorCode,hi2c3.State);
    427.         return  HAL_ERROR;
    428.     }
    429.     return HAL_OK ;
    430. }
    431.  
    432. uint16_t gc0329_ReadID(uint16_t dummy)
    433. {  
    434.   /* Get the camera ID */
    435.  // CAMERA_IO_Write(0xfe, 0x00);
    436. //  CAMERA_IO_Write(GC0329_I2CADDR,0xfe, 0x48);
    437.   CAMERA_IO_Write(GC0329_I2CADDR,0xfc, 0x16);
    438.   return (CAMERA_IO_Read(GC0329_I2CADDR, GC0329_CHIPID));
    439. }
    440.  
    441. void gc0329_Init(uint16_t DeviceAddr, uint32_t resolution)
    442. {
    443.     uint32_t index;
    444.  
    445.     /* Initialize GC0329 */
    446.     switch (resolution)
    447.     {
    448.         case CAMERA_R160x120:
    449.         {
    450.             for(index = 0; index < (sizeof(GC0329_QQVGA) / 2); index++)
    451.             {
    452.                 CAMERA_IO_Write(DeviceAddr, GC0329_QQVGA[index][0], GC0329_QQVGA[index][1]);
    453.                 HAL_Delay(2);
    454.             }
    455.  
    456.             break;
    457.         }
    458.  
    459.         case CAMERA_R320x240:
    460.         {
    461.             for(index = 0; index < (sizeof(GC0329_QVGA) / 2); index++)
    462.             {
    463.                 CAMERA_IO_Write(DeviceAddr, GC0329_QVGA[index][0], GC0329_QVGA[index][1]);
    464.                 HAL_Delay(2);
    465.             }
    466.  
    467.             break;
    468.         }
    469.  
    470.         case CAMERA_R480x272:
    471.         {
    472.             /* Not supported resolution */
    473.             break;
    474.         }
    475.  
    476.         case CAMERA_R640x480:
    477.         {
    478.             for(index = 0; index < (sizeof(GC0329_VGA) / 2); index++)
    479.             {
    480.                 CAMERA_IO_Write(DeviceAddr, GC0329_VGA[index][0], GC0329_VGA[index][1]);
    481.                 HAL_Delay(2);
    482.             }
    483.  
    484.             break;
    485.         }
    486.  
    487.         default:
    488.         {
    489.             break;
    490.         }
    491.     }
    492. }
    493.  
    494. void gc0329_Config(uint16_t DeviceAddr, uint32_t feature, uint32_t value, uint32_t brightness_value)
    495. {
    496.     /* Convert the input value into gc0329 parameters */
    497.     gc0329_ConvertValue(feature, value);
    498.     gc0329_ConvertValue(CAMERA_CONTRAST_BRIGHTNESS, brightness_value);
    499. }
    500.  
    501. uint64_t gc0329_ConvertValue(uint32_t feature, uint32_t value)
    502. {
    503. //    uint64_t ret = 0;
    504.     return 0;
    505. 		#if 0
    506.     switch(feature)
    507.     {
    508.         case CAMERA_BLACK_WHITE:
    509.         {
    510.             switch(value)
    511.             {
    512.                 case CAMERA_BLACK_WHITE_BW:
    513.                 {
    514.                     ret =  GC0329_BLACK_WHITE_BW;
    515.                     break;
    516.                 }
    517.  
    518.                 case CAMERA_BLACK_WHITE_NEGATIVE:
    519.                 {
    520.                     ret =  GC0329_BLACK_WHITE_NEGATIVE;
    521.                     break;
    522.                 }
    523.  
    524.                 case CAMERA_BLACK_WHITE_BW_NEGATIVE:
    525.                 {
    526.                     ret =  GC0329_BLACK_WHITE_BW_NEGATIVE;
    527.                     break;
    528.                 }
    529.  
    530.                 case CAMERA_BLACK_WHITE_NORMAL:
    531.                 {
    532.                     ret =  GC0329_BLACK_WHITE_NORMAL;
    533.                     break;
    534.                 }
    535.  
    536.                 default:
    537.                 {
    538.                     ret =  GC0329_BLACK_WHITE_NORMAL;
    539.                     break;
    540.                 }
    541.             }
    542.  
    543.             break;
    544.         }
    545.  
    546.         case CAMERA_CONTRAST_BRIGHTNESS:
    547.         {
    548.             switch(value)
    549.             {
    550.                 case CAMERA_BRIGHTNESS_LEVEL0:
    551.                 {
    552.                     ret =  GC0329_BRIGHTNESS_LEVEL0;
    553.                     break;
    554.                 }
    555.  
    556.                 case CAMERA_BRIGHTNESS_LEVEL1:
    557.                 {
    558.                     ret =  GC0329_BRIGHTNESS_LEVEL1;
    559.                     break;
    560.                 }
    561.  
    562.                 case CAMERA_BRIGHTNESS_LEVEL2:
    563.                 {
    564.                     ret =  GC0329_BRIGHTNESS_LEVEL2;
    565.                     break;
    566.                 }
    567.  
    568.                 case CAMERA_BRIGHTNESS_LEVEL3:
    569.                 {
    570.                     ret =  GC0329_BRIGHTNESS_LEVEL3;
    571.                     break;
    572.                 }
    573.  
    574.                 case CAMERA_BRIGHTNESS_LEVEL4:
    575.                 {
    576.                     ret =  GC0329_BRIGHTNESS_LEVEL4;
    577.                     break;
    578.                 }
    579.  
    580.                 case CAMERA_CONTRAST_LEVEL0:
    581.                 {
    582.                     ret =  GC0329_CONTRAST_LEVEL0;
    583.                     break;
    584.                 }
    585.  
    586.                 case CAMERA_CONTRAST_LEVEL1:
    587.                 {
    588.                     ret =  GC0329_CONTRAST_LEVEL1;
    589.                     break;
    590.                 }
    591.  
    592.                 case CAMERA_CONTRAST_LEVEL2:
    593.                 {
    594.                     ret =  GC0329_CONTRAST_LEVEL2;
    595.                     break;
    596.                 }
    597.  
    598.                 case CAMERA_CONTRAST_LEVEL3:
    599.                 {
    600.                     ret =  GC0329_CONTRAST_LEVEL3;
    601.                     break;
    602.                 }
    603.  
    604.                 case CAMERA_CONTRAST_LEVEL4:
    605.                 {
    606.                     ret =  GC0329_CONTRAST_LEVEL4;
    607.                     break;
    608.                 }
    609.  
    610.                 default:
    611.                 {
    612.                     ret =  GC0329_CONTRAST_LEVEL0;
    613.                     break;
    614.                 }
    615.             }
    616.  
    617.             break;
    618.         }
    619.  
    620.         case CAMERA_COLOR_EFFECT:
    621.         {
    622.             switch(value)
    623.             {
    624.                 case CAMERA_COLOR_EFFECT_ANTIQUE:
    625.                 {
    626.                     ret =  GC0329_COLOR_EFFECT_ANTIQUE;
    627.                     break;
    628.                 }
    629.  
    630.                 case CAMERA_COLOR_EFFECT_BLUE:
    631.                 {
    632.                     ret =  GC0329_COLOR_EFFECT_BLUE;
    633.                     break;
    634.                 }
    635.  
    636.                 case CAMERA_COLOR_EFFECT_GREEN:
    637.                 {
    638.                     ret =  GC0329_COLOR_EFFECT_GREEN;
    639.                     break;
    640.                 }
    641.  
    642.                 case CAMERA_COLOR_EFFECT_RED:
    643.                 {
    644.                     ret =  GC0329_COLOR_EFFECT_RED;
    645.                     break;
    646.                 }
    647.  
    648.                 case CAMERA_COLOR_EFFECT_NONE:
    649.                 default:
    650.                 {
    651.                     ret =  GC0329_COLOR_EFFECT_NONE;
    652.                     break;
    653.                 }
    654.             }
    655.  
    656.             break;
    657.  
    658.             default:
    659.             {
    660.                 ret = 0;
    661.                 break;
    662.             }
    663.         }
    664.     }
    665. 		#endif
    666. //    return ret;
    667. }
    668.  
    669. uint8_t camera_dis_on = 0;
    670.  
    671. void enable_camera_display(uint8_t on)
    672. {
    673.     camera_dis_on = on;
    674. }
    675.  
    676. void CAMERA_Init(uint32_t Resolution)
    677. {
    678.     camera_drv = &gc0329_drv;
    679.     phdcmi = &hdcmi;
    680.  
    681.     /* Camera Module Initialization via I2C to the wanted 'Resolution' */
    682.     if (Resolution == CAMERA_R640x480)
    683.     {
    684.         /* For 240x240 resolution, the OV9655 sensor is set to QVGA resolution
    685.          * as OV9655 doesn't supports 240x240  resolution,
    686.          * then DCMI is configured to output a 240x240 cropped window */
    687.         camera_drv->Init(GC0329_I2CADDR, CAMERA_R640x480);
    688.  
    689.  
    690.         HAL_DCMI_ConfigCROP(phdcmi,
    691.                             150,                 /* Crop in the middle of the VGA picture */
    692.                             120,                 /* Same height (same number of lines: no need to crop vertically) */
    693.                             (WIDTH * 2) - 1,     /* 2 pixels clock needed to capture one pixel */
    694.                             (HEIGHT * 1) - 1);    /* All 240 lines are captured */
    695.         HAL_DCMI_EnableCROP(phdcmi);
    696.     }
    697. }
    698.  
    699. void CameraDEMO_Init()
    700. {
    701. 	uint16_t buff[WIDTH * HEIGHT] = {LCD_DISP_BLUE};
    702.     camera_buff = buff;
    703. //    camera_dispaly(camera_buff, (WIDTH * HEIGHT));
    704.  
    705.     gc0329_power_onoff(1);
    706.     uint8_t sensor_id = gc0329_ReadID(0);
    707.     printf("camera sensor_id = 0x%02X\r\n", sensor_id);
    708.     /* gc0329_power_onoff(0); */
    709.     if (sensor_id == GC0329_ID)
    710.     {
    711.         CAMERA_Init(CAMERA_R640x480);
    712.         /* Wait 1s to let auto-loops in the camera module converge and lead to correct exposure */
    713.         /* aos_msleep(1000); */
    714.         HAL_Delay(200);
    715.         /*##-4- Camera Continuous capture start in QVGA resolution ############################*/
    716.         /* Disable unwanted HSYNC (IT_LINE)/VSYNC interrupts */
    717.         __HAL_DCMI_DISABLE_IT(phdcmi, DCMI_IT_LINE | DCMI_IT_VSYNC);
    718.  
    719.         /* LCD size is 240 x 240 and format is RGB565 i.e. 16 bpp or 2 bytes/pixel.
    720.            The LCD frame size is therefore 240 * 240 half-words of (240*240)/2 32-bit long words .
    721.            Since the DMA associated to DCMI IP is configured in  BSP_CAMERA_MspInit() of stm32l496g_discovery_camera.c file
    722.            with words alignment, the last parameter of HAL_DCMI_Start_DMA is set to:
    723.             (ST7789H2_LCD_PIXEL_WIDTH*ST7789H2_LCD_PIXEL_HEIGHT)/2, that is 240 * 240 / 2
    724.          */
    725.         HAL_DCMI_Start_DMA(phdcmi, DCMI_MODE_CONTINUOUS, (uint32_t)camera_buff, (WIDTH * HEIGHT) / 2);
    726.         /* OnError_Handler(hal_status != HAL_OK); */
    727.     }
    728. }
    729.  
    730. void GC0329_CAMERA_FrameEventCallback(void)
    731. {
    732.     if (pCapFunc)
    733.     {
    734.         pCapFunc();
    735.         return;
    736.     }
    737.  
    738.     if (camera_dis_on)
    739.     {
    740.         HAL_DCMI_Suspend(phdcmi);
    741.         camera_dispaly(camera_buff, (WIDTH * HEIGHT));
    742.         HAL_DCMI_Start_DMA(phdcmi, DCMI_MODE_CONTINUOUS, (uint32_t)camera_buff, (WIDTH * HEIGHT) / 2);
    743.         HAL_DCMI_Resume(phdcmi);
    744.     }
    745. }
    746.  
    747. /**
    748.   * @brief  Frame event callback
    749.   * @param  hdcmi: pointer to the DCMI handle
    750.   * @retval None
    751.   */
    752. void HAL_DCMI_FrameEventCallback(DCMI_HandleTypeDef *hdcmi)
    753. {
    754.     GC0329_CAMERA_FrameEventCallback();
    755. }
    756.  
    757. int CameraHAL_Capture_Config(uint16_t w, uint16_t h)
    758. {
    759.     HAL_StatusTypeDef hal_status = HAL_OK;
    760.  
    761.     if (w > 640 || h > 480) return 0;
    762.  
    763.     camera_drv = &gc0329_drv;
    764.     phdcmi = &hdcmi;
    765.  
    766.     gc0329_power_onoff(1);
    767.     camera_drv->Init(GC0329_I2CADDR, CAMERA_R640x480);
    768.  
    769.     HAL_DCMI_ConfigCROP(phdcmi,
    770.                         (640 - w) >> 1,                 /* Crop in the middle of the VGA picture */
    771.                         (480 - h) >> 1,                 /* Same height (same number of lines: no need to crop vertically) */
    772.                         (w * 1) - 1,     /* 2 pixels clock needed to capture one pixel */
    773.                         (w * 1) - 1);    /* All 240 lines are captured */
    774.     HAL_DCMI_EnableCROP(phdcmi);
    775.  
    776.     HAL_Delay(1000);
    777.  
    778.     __HAL_DCMI_DISABLE_IT(phdcmi, DCMI_IT_LINE | DCMI_IT_VSYNC);
    779.  
    780.     return hal_status == HAL_OK;
    781. }
    782.  
    783. int CameraHAL_Capture_Start(uint8_t * buf, uint32_t len, void(*notify)())
    784. {
    785.     HAL_StatusTypeDef hal_status = HAL_OK;
    786.  
    787.     pCapFunc = notify;
    788.  
    789.     if (pCapFunc)
    790.     {
    791.         hal_status = HAL_DCMI_Start_DMA(phdcmi, DCMI_MODE_SNAPSHOT, (uint32_t)buf, len);
    792.     }
    793.  
    794.     return hal_status == HAL_OK;
    795. }

    五、编辑及测试

            【1】在main.c转函数文件中，加入camera.h的引用

    1. /* USER CODE BEGIN Includes */
    2. #include "../../ICore/key/key.h"
    3. #include "../../ICore/led/led.h"
    4. #include "../../ICore/print/print.h"
    5. #include "../../ICore/usart/usart.h"
    6. #include "../../ICore/oled/oled.h"
    7. #include "../../ICore/cam/camera.h"
    8. /* USER CODE END Includes */

            在主函数内调用camera的初始函数

    1.   /* USER CODE BEGIN 2 */
    2.   ResetPrintInit(&hlpuart1);
    3.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
    4.   HLPUSART_RX_STA = 0;
    5.   //
    6.   OLED_init();
    7.   //
    8.   CameraDEMO_Init();
    9.   uint8_t flag = 0x00;
    10.   uint8_t bkflag = 0X00;
    11.   /* USER CODE END 2 */

            【2】在主函数循环体内，设置通过按键2开启或关闭摄像头抓取数据推送LCD屏幕显示的功能

    1.  /* USER CODE BEGIN WHILE */
    2.   while (1)
    3.   {
    4. 	  if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
    5. 		  //设置OLED蓝色背景显示
    6. 		  if(!bkflag){
    7. 			  BSP_LCD_Clear_DMA(LCD_DISP_BLUE);
    8. 			  bkflag = 0x01;
    9. 		  }
    10. //		  printf("OLED_Clear_DMA\r\n");
    11. 		  //printf("%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
    12. 		  OLED_printf(10,10,"%.*s",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
    13. 		  HLPUSART_RX_STA=0;//接收错误,重新开始
    14. 		  HAL_Delay(100);//等待
    15. 	  }
    16. 	  if(KEY_0())
    17. 	  {
    18. 		  BSP_LCD_login(24,108);
    19. 		  bkflag = 0x00;
    20. 	  }
    21. 	  if(KEY_1())
    22.   	  {
    23. 		  BSP_LCD_img_DMA();
    24. 		  bkflag = 0x00;
    25.   	  }
    26. 	  if(KEY_2())
    27.   	  {
    28. 		  flag = !flag;
    29. 		  enable_camera_display(flag);
    30. 		  bkflag = 0x00;
    31.   	  }
    32.     /* USER CODE END WHILE */

            【3】在运行按钮下拉选择，进入运行配置界面，新建运行配置，默认配置。

             【4】编译及下载

           【5】 按键2，测试视频显示输出

  • 相关阅读:
    java-net-php-python-jsp学生创新项目系统计算机毕业设计程序
    【Linux学习】Linux编辑器-vim使用
    CMake使用基础汇总
    汇编 -- arm架构的ldmia与stmia指令
    【校招VIP】前端JS语言考点之选择器和优先级
    HarmonyOS Codelab 优秀样例——溪村小镇（ArkTS）
    Delphi使用JSON
    聊聊电商系统架构演进
    uniapp之路由中携带参数跳转
    小程序开发音视频问题汇总及解决方案
  • 原文地址：https://blog.csdn.net/py8105/article/details/128187886