CloudEdge/bl_mcu_sdk
Archived
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

[refactor][cam] refactor camera driver,add standard interfaces for camera

Browse Source
This commit is contained in:
jzlv 2021-10-25 15:14:04 +08:00
parent 9792e36ab4
commit e27aedace2
20 changed files with 404 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bsp/board/bl702/bl702_boot2/clock_config.h
View File

@ -77,7 +77,7 @@
#define BSP_DAC_CLOCK_SOURCE ROOT_CLOCK_SOURCE_AUPLL_24000000_HZ
#define BSP_DAC_CLOCK_DIV 1
#endif
#if defined(BSP_USING_CAM)
#if defined(BSP_USING_CAM0)
#define BSP_CAM_CLOCK_SOURCE ROOT_CLOCK_SOURCE_PLL_96M
#define BSP_CAM_CLOCK_DIV 3
#endif

2
bsp/board/bl702/bl702_iot/clock_config.h
View File

@ -72,7 +72,7 @@
#define BSP_DAC_CLOCK_SOURCE ROOT_CLOCK_SOURCE_AUPLL_24000000_HZ
#define BSP_DAC_CLOCK_DIV 1
#endif
#if defined(BSP_USING_CAM)
#if defined(BSP_USING_CAM0)
#define BSP_CAM_CLOCK_SOURCE ROOT_CLOCK_SOURCE_PLL_96M
#define BSP_CAM_CLOCK_DIV 3
#endif

2
bsp/board/bl702/bl706_avb/clock_config.h
View File

@ -76,7 +76,7 @@
#define BSP_DAC_CLOCK_SOURCE ROOT_CLOCK_SOURCE_AUPLL_24000000_HZ
#define BSP_DAC_CLOCK_DIV 1
#endif
#if defined(BSP_USING_CAM)
#if defined(BSP_USING_CAM0)
#define BSP_CAM_CLOCK_SOURCE ROOT_CLOCK_SOURCE_PLL_96M
#define BSP_CAM_CLOCK_DIV 3
#endif

24
bsp/board/bl702/bl706_avb/peripheral_config.h
View File

@ -44,7 +44,7 @@
#define BSP_USING_QDEC1
#define BSP_USING_QDEC2
#define BSP_USING_USB
#define BSP_USING_CAM
#define BSP_USING_CAM0
/* ----------------------*/
/* PERIPHERAL With DMA LIST */
@ -125,6 +125,8 @@
.clk_phase = SPI_PHASE_1EDGE, \
.datasize = SPI_DATASIZE_8BIT, \
.fifo_threshold = 4, \
.pin_swap_enable = 1, \
.delitch_cnt = 0, \
}
#endif
#endif
@ -462,4 +464,24 @@
#endif
#endif
#if defined(BSP_USING_CAM0)
#ifndef CAM0_CONFIG
#define CAM0_CONFIG \
{ \
.id = 0, \
.software_mode = CAM_AUTO_MODE, \
.frame_mode = CAM_FRAME_INTERLEAVE_MODE, \
.yuv_format = CAM_YUV_FORMAT_YUV422, \
.hsp = CAM_HSPOLARITY_LOW, \
.vsp = CAM_VSPOLARITY_LOW, \
.cam_write_ram_addr = 0, \
.cam_write_ram_size = 0, \
.cam_frame_size = 0, \
.cam_write_ram_addr1 = 0, \
.cam_write_ram_size1 = 0, \
.cam_frame_size1 = 0, \
}
#endif
#endif
#endif

2
bsp/board/bl702/bl706_iot/clock_config.h
View File

@ -72,7 +72,7 @@
#define BSP_DAC_CLOCK_SOURCE ROOT_CLOCK_SOURCE_AUPLL_24000000_HZ
#define BSP_DAC_CLOCK_DIV 1
#endif
#if defined(BSP_USING_CAM)
#if defined(BSP_USING_CAM0)
#define BSP_CAM_CLOCK_SOURCE ROOT_CLOCK_SOURCE_PLL_96M
#define BSP_CAM_CLOCK_DIV 3
#endif

2
bsp/board/bl702/bl706_iot/peripheral_config.h
View File

@ -125,6 +125,8 @@
.clk_phase = SPI_PHASE_1EDGE, \
.datasize = SPI_DATASIZE_8BIT, \
.fifo_threshold = 1, \
.pin_swap_enable = 1, \
.delitch_cnt = 0, \
}
#endif
#endif

2
bsp/board/bl702/bl706_lp/clock_config.h
View File

@ -60,7 +60,7 @@
#define BSP_DAC_CLOCK_SOURCE ROOT_CLOCK_SOURCE_AUPLL_24000000_HZ
#define BSP_DAC_CLOCK_DIV 1
#endif
#if defined(BSP_USING_CAM)
#if defined(BSP_USING_CAM0)
#define BSP_CAM_CLOCK_SOURCE ROOT_CLOCK_SOURCE_PLL_96M
#define BSP_CAM_CLOCK_DIV 3
#endif

41
bsp/bsp_common/image_sensor/bsp_image_sensor.c
View File

@ -679,24 +679,37 @@ uint8_t image_sensor_init(BL_Fun_Type mjpeg_en, cam_device_t *cam_cfg, mjpeg_dev
return 1;
}
cam_stop();
mjpeg_stop();
if (mjpeg_en) {
#if (CAM_MODE == CAM_USING_INT_MODE)
cam_init(cam_cfg, DEVICE_OFLAG_INT);
#elif (CAM_MODE == CAM_USING_POLL_MODE)
cam_init(cam_cfg, DEVICE_OFLAG_POLL);
#endif
mjpeg_init(mjpeg_cfg);
} else {
#if (CAM_MODE == CAM_USING_INT_MODE)
cam_init(cam_cfg, DEVICE_OFLAG_INT);
#elif (CAM_MODE == CAM_USING_POLL_MODE)
cam_init(cam_cfg, DEVICE_OFLAG_POLL);
#endif
cam_register(CAM0_INDEX, "camera0");
struct device *cam0 = device_find("camera0");
if(!cam0)
{
MSG("cam do not find\r\n");
return 1;
}
if (mjpeg_en) {
mjpeg_init(mjpeg_cfg);
}
CAM_DEV(cam0)->hsp = CAM_HSPOLARITY_HIGH;
CAM_DEV(cam0)->vsp = CAM_VSPOLARITY_HIGH;
CAM_DEV(cam0)->software_mode = cam_cfg->software_mode;
CAM_DEV(cam0)->frame_mode = cam_cfg->frame_mode;
CAM_DEV(cam0)->yuv_format = cam_cfg->yuv_format;
CAM_DEV(cam0)->cam_write_ram_addr = cam_cfg->cam_write_ram_addr;
CAM_DEV(cam0)->cam_write_ram_size = cam_cfg->cam_write_ram_size;
CAM_DEV(cam0)->cam_frame_size = cam_cfg->cam_frame_size;
CAM_DEV(cam0)->cam_write_ram_addr1 = cam_cfg->cam_write_ram_addr1;
CAM_DEV(cam0)->cam_write_ram_size1 = cam_cfg->cam_write_ram_size1;
CAM_DEV(cam0)->cam_frame_size1 = cam_cfg->cam_frame_size1;
#if (CAM_MODE == CAM_USING_INT_MODE)
device_open(cam0, DEVICE_OFLAG_INT_RX);
#elif (CAM_MODE == CAM_USING_POLL_MODE)
device_open(cam0, DEVICE_OFLAG_STREAM_RX);
#endif
return SUCCESS;
}

98
drivers/bl702_driver/hal_drv/inc/hal_cam.h
View File

@ -25,54 +25,69 @@
#define __HAL_CAM_H__
#ifdef __cplusplus
extern "C"{
extern "C" {
#endif
#include "hal_common.h"
#include "drv_device.h"
#include "bl702_config.h"
#include "bl702_cam.h"
#define DEVICE_OFLAG_INT 0x01
#define DEVICE_OFLAG_POLL 0x02
#define DEVICE_CTRL_CAM_FRAME_CUT 0x10
#define DEVICE_CTRL_CAM_FRAME_DROP 0x11
enum camera_event_type {
CAM_EVENT_NORMAL_0, /*!< Interleave mode: normal write interrupt, planar mode:even byte normal write interrupt */
CAM_EVENT_NORMAL_1, /*!< Interleave mode: no use, planar mode:odd byte normal write interrupt */
CAM_EVENT_MEMORY_OVERWRITE_0, /*!< Interleave mode: memory overwrite interrupt, planar mode:even byte memory overwrite interrupt */
CAM_EVENT_MEMORY_OVERWRITE_1, /*!< Interleave mode: no use, planar mode:odd byte memory overwrite interrupt */
CAM_EVENT_FRAME_OVERWRITE_0, /*!< Interleave mode: frame overwrite interrupt, planar mode:even byte frame overwrite interrupt */
CAM_EVENT_FRAME_OVERWRITE_1, /*!< Interleave mode: no use, planar mode:odd byte frame overwrite interrupt */
CAM_EVENT_FIFO_OVERWRITE_0, /*!< Interleave mode: fifo overwrite interrupt, planar mode:even byte fifo overwrite interrupt */
CAM_EVENT_FIFO_OVERWRITE_1, /*!< Interleave mode: no use, planar mode:odd byte fifo overwrite interrupt */
CAM_EVENT_VSYNC_CNT_ERROR, /*!< Vsync valid line count non-match interrupt */
CAM_EVENT_HSYNC_CNT_ERROR, /*!< Hsync valid pixel count non-match interrupt */
CAM_EVENT_ALL, /*!< All of interrupt */
enum cam_index_type {
#ifdef BSP_USING_CAM0
CAM0_INDEX,
#endif
CAM_MAX_INDEX
};
typedef enum {
CAM_AUTO_MODE,
CAM_MANUAL_MODE,
} cam_software_mode_t;
#define CAM_AUTO_MODE 0
#define CAM_MANUAL_MODE 1
typedef enum {
CAM_FRAME_PLANAR_MODE,
CAM_FRAME_INTERLEAVE_MODE,
} cam_frame_mode_t;
#define CAM_FRAME_PLANAR_MODE 0
#define CAM_FRAME_INTERLEAVE_MODE 1
typedef enum {
CAM_YUV_FORMAT_YUV422,
CAM_YUV_FORMAT_YUV420_EVEN,
CAM_YUV_FORMAT_YUV420_ODD,
CAM_YUV_FORMAT_YUV400_EVEN,
CAM_YUV_FORMAT_YUV400_ODD,
} cam_yuv_format_t;
#define CAM_HSPOLARITY_LOW 0
#define CAM_HSPOLARITY_HIGH 1
#define CAM_VSPOLARITY_LOW 0
#define CAM_VSPOLARITY_HIGH 1
#define CAM_YUV_FORMAT_YUV422 0
#define CAM_YUV_FORMAT_YUV420_EVEN 1
#define CAM_YUV_FORMAT_YUV420_ODD 2
#define CAM_YUV_FORMAT_YUV400_EVEN 3
#define CAM_YUV_FORMAT_YUV400_ODD 4
enum cam_it_type {
CAM_FRAME_IT = 1 << 0,
};
enum cam_event_type {
CAM_EVENT_FRAME = 0,
};
typedef struct {
int16_t x0;
int16_t x1;
int16_t y0;
int16_t y1;
} cam_frame_area_t;
typedef struct {
uint32_t frame_addr;
uint32_t frame_count;
} cam_frame_info_t;
typedef struct cam_device {
struct device parent;
cam_software_mode_t software_mode;
cam_frame_mode_t frame_mode;
cam_yuv_format_t yuv_format;
uint8_t id;
uint8_t software_mode;
uint8_t frame_mode;
uint8_t yuv_format;
uint8_t hsp;
uint8_t vsp;
uint32_t cam_write_ram_addr;
uint32_t cam_write_ram_size;
uint32_t cam_frame_size;
@ -83,19 +98,14 @@ typedef struct cam_device {
uint32_t cam_frame_size1;
} cam_device_t;
void cam_init(cam_device_t *cam_cfg, uint16_t oflag);
void cam_start(void);
void cam_stop(void);
uint8_t cam_get_one_frame_interleave(uint8_t **pic, uint32_t *len);
uint8_t cam_get_one_frame_planar(CAM_YUV_Mode_Type yuv, uint8_t **picYY, uint32_t *lenYY, uint8_t **picUV, uint32_t *lenUV);
#define CAM_DEV(dev) ((cam_device_t *)dev)
int cam_register(enum cam_index_type index, const char *name);
void cam_drop_one_frame_interleave(void);
void cam_drop_one_frame_planar(void);
void cam_hsync_crop(uint16_t start, uint16_t end);
void cam_vsync_crop(uint16_t start, uint16_t end);
void cam_hw_mode_wrap(uint8_t enbale);
void CAM_Int_Callback_set(CAM_INT_Type intType, intCallback_Type *cbFun);
uint8_t cam_get_one_frame_interleave(uint8_t **pic, uint32_t *len);
#ifdef __cplusplus
}
#endif
#endif

392
drivers/bl702_driver/hal_drv/src/hal_cam.c
View File

@ -20,57 +20,250 @@
* under the License.
*
*/
#include "hal_cam.h"
#include "bl702_cam.h"
#include "bl702_glb.h"
#include "hal_cam.h"
#ifdef BSP_USING_CAM
static intCallback_Type *camIntCbfArra[CAM_INT_ALL] = { NULL };
void CAMERA_IRQ(void);
#ifdef BSP_USING_CAM0
static void CAM0_IRQ(void);
#endif
static cam_device_t camx_device[CAM_MAX_INDEX] = {
#ifdef BSP_USING_CAM0
CAM0_CONFIG,
#endif
};
/**
* @brief
*
* @param cam_cfg
* @param dev
* @param oflag
* @return int
*/
void cam_init(cam_device_t *cam_cfg, uint16_t oflag)
int cam_open(struct device *dev, uint16_t oflag)
{
CAM_CFG_Type camera_cfg = {
.swMode = cam_cfg->software_mode,
.swIntCnt = 0,
.frameMode = cam_cfg->frame_mode,
.yuvMode = cam_cfg->yuv_format,
.waitCount = 0x40,
.linePol = CAM_LINE_ACTIVE_POLARITY_HIGH,
.framePol = CAM_FRAME_ACTIVE_POLARITY_HIGH,
.burstType = CAM_BURST_TYPE_INCR16,
.camSensorMode = CAM_SENSOR_MODE_V_AND_H,
.memStart0 = cam_cfg->cam_write_ram_addr,
.memSize0 = cam_cfg->cam_write_ram_size,
.frameSize0 = cam_cfg->cam_frame_size,
/* planar mode*/
.memStart1 = cam_cfg->cam_write_ram_addr1,
.memSize1 = cam_cfg->cam_write_ram_size1,
.frameSize1 = cam_cfg->cam_frame_size1,
};
cam_device_t *cam_device = (cam_device_t *)dev;
CAM_CFG_Type camera_cfg = { 0 };
uint32_t tmpVal;
/* Disable camera module */
tmpVal = BL_RD_REG(CAM_BASE, CAM_DVP2AXI_CONFIGUE);
tmpVal = BL_CLR_REG_BIT(tmpVal, CAM_REG_DVP_ENABLE);
BL_WR_REG(CAM_BASE, CAM_DVP2AXI_CONFIGUE, tmpVal);
camera_cfg.swMode = cam_device->software_mode;
camera_cfg.frameMode = cam_device->frame_mode;
camera_cfg.yuvMode = cam_device->yuv_format;
camera_cfg.waitCount = 0x40;
camera_cfg.linePol = cam_device->hsp;
camera_cfg.framePol = cam_device->vsp;
camera_cfg.burstType = CAM_BURST_TYPE_INCR16;
camera_cfg.camSensorMode = CAM_SENSOR_MODE_V_AND_H;
camera_cfg.memStart0 = cam_device->cam_write_ram_addr;
camera_cfg.memSize0 = cam_device->cam_write_ram_size;
camera_cfg.frameSize0 = cam_device->cam_frame_size;
/* planar mode*/
camera_cfg.memStart1 = cam_device->cam_write_ram_addr1;
camera_cfg.memSize1 = cam_device->cam_write_ram_size1;
camera_cfg.frameSize1 = cam_device->cam_frame_size1;
CAM_Init(&camera_cfg);
if (oflag == DEVICE_OFLAG_INT) {
#ifdef BSP_USING_CAM
Interrupt_Handler_Register(CAM_IRQn, CAMERA_IRQ);
if (oflag & DEVICE_OFLAG_INT_RX) {
#ifdef BSP_USING_CAM0
Interrupt_Handler_Register(CAM_IRQn, CAM0_IRQ);
#endif
}
return 0;
}
/**
* @brief
*
* @param dev
* @return int
*/
int cam_close(struct device *dev)
{
GLB_AHB_Slave1_Reset(BL_AHB_SLAVE1_CAM);
return 0;
}
/**
* @brief
*
* @param dev
* @param cmd
* @param args
* @return int
*/
int cam_control(struct device *dev, int cmd, void *args)
{
cam_device_t *cam_device = (cam_device_t *)dev;
switch (cmd) {
case DEVICE_CTRL_SET_INT:
if ((uint32_t)args == CAM_FRAME_IT) {
CAM_IntMask(CAM_INT_NORMAL_0, UNMASK);
CPU_Interrupt_Enable(CAM_IRQn);
}
break;
case DEVICE_CTRL_CLR_INT:
if ((uint32_t)args == CAM_FRAME_IT) {
CAM_IntMask(CAM_INT_NORMAL_0, MASK);
CPU_Interrupt_Disable(CAM_IRQn);
}
break;
case DEVICE_CTRL_RESUME: {
uint32_t tmpVal;
/* Enable camera module */
tmpVal = BL_RD_REG(CAM_BASE, CAM_DVP2AXI_CONFIGUE);
tmpVal = BL_SET_REG_BIT(tmpVal, CAM_REG_DVP_ENABLE);
BL_WR_REG(CAM_BASE, CAM_DVP2AXI_CONFIGUE, tmpVal);
} break;
case DEVICE_CTRL_SUSPEND: {
uint32_t tmpVal;
/* Disable camera module */
tmpVal = BL_RD_REG(CAM_BASE, CAM_DVP2AXI_CONFIGUE);
tmpVal = BL_CLR_REG_BIT(tmpVal, CAM_REG_DVP_ENABLE);
BL_WR_REG(CAM_BASE, CAM_DVP2AXI_CONFIGUE, tmpVal);
} break;
case DEVICE_CTRL_CAM_FRAME_CUT: {
cam_frame_area_t *cfg = (cam_frame_area_t *)args;
BL_WR_REG(CAM_BASE, CAM_HSYNC_CONTROL, ((cfg->x0 * 2) << 16) + (cfg->x1 * 2));
BL_WR_REG(CAM_BASE, CAM_VSYNC_CONTROL, ((cfg->y0) << 16) + cfg->y1);
} break;
case DEVICE_CTRL_CAM_FRAME_DROP:
if (cam_device->frame_mode == CAM_FRAME_INTERLEAVE_MODE) {
/* Pop one frame */
BL_WR_REG(CAM_BASE, CAM_DVP_FRAME_FIFO_POP, 1);
} else {
/* Pop one frame */
BL_WR_REG(CAM_BASE, CAM_DVP_FRAME_FIFO_POP, 3);
}
break;
default:
break;
}
return 0;
}
/**
* @brief
*
* @param dev
* @param pos
* @param buffer
* @param size
* @return int
*/
int cam_read(struct device *dev, uint32_t pos, void *buffer, uint32_t size)
{
if (!BL_GET_REG_BITS_VAL(BL_RD_REG(CAM_BASE, CAM_DVP_STATUS_AND_ERROR), CAM_FRAME_VALID_CNT_0)) {
return -1;
}
cam_frame_info_t *frame_info = (cam_frame_info_t *)buffer;
frame_info->frame_addr = BL_RD_REG(CAM_BASE, CAM_FRAME_START_ADDR0_0);
frame_info->frame_count = BL_RD_REG(CAM_BASE, CAM_FRAME_BYTE_CNT0_0);
return 0;
}
/**
* @brief
*
* @param index
* @param name
* @return int
*/
int cam_register(enum cam_index_type index, const char *name)
{
struct device *dev;
if (CAM_MAX_INDEX == 0) {
return -DEVICE_EINVAL;
}
dev = &(camx_device[index].parent);
dev->open = cam_open;
dev->close = cam_close;
dev->control = cam_control;
dev->write = NULL;
dev->read = cam_read;
dev->type = DEVICE_CLASS_CAMERA;
dev->handle = NULL;
return device_register(dev, name);
}
void cam_isr(cam_device_t *handle)
{
uint32_t tmpVal;
if (!handle->parent.callback)
return;
tmpVal = BL_RD_REG(CAM_BASE, CAM_DVP_STATUS_AND_ERROR);
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_NORMAL_INT_0)) {
handle->parent.callback(&handle->parent, NULL, 0, CAM_EVENT_FRAME);
CAM_IntClr(CAM_INT_NORMAL_0);
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_NORMAL_INT_1)) {
CAM_IntClr(CAM_INT_NORMAL_1);
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_MEM_INT_0)) {
CAM_IntClr(CAM_INT_MEMORY_OVERWRITE_0);
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_MEM_INT_1)) {
CAM_IntClr(CAM_INT_MEMORY_OVERWRITE_1);
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_FRAME_INT_0)) {
CAM_IntClr(CAM_INT_FRAME_OVERWRITE_0);
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_FRAME_INT_1)) {
CAM_IntClr(CAM_INT_FRAME_OVERWRITE_1);
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_FIFO_INT_0)) {
CAM_IntClr(CAM_INT_FIFO_OVERWRITE_0);
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_FIFO_INT_1)) {
CAM_IntClr(CAM_INT_FIFO_OVERWRITE_1);
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_HCNT_INT)) {
CAM_IntClr(CAM_INT_HSYNC_CNT_ERROR);
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_VCNT_INT)) {
CAM_IntClr(CAM_INT_VSYNC_CNT_ERROR);
}
}
#ifdef BSP_USING_CAM0
void CAM0_IRQ(void)
{
cam_isr(&camx_device[CAM0_INDEX]);
}
#endif
/**
* @brief
*
*/
void cam_start(void)
{
CAM_Enable();
uint32_t tmpVal;
/* Enable camera module */
tmpVal = BL_RD_REG(CAM_BASE, CAM_DVP2AXI_CONFIGUE);
tmpVal = BL_SET_REG_BIT(tmpVal, CAM_REG_DVP_ENABLE);
BL_WR_REG(CAM_BASE, CAM_DVP2AXI_CONFIGUE, tmpVal);
}
/**
@ -79,7 +272,12 @@ void cam_start(void)
*/
void cam_stop(void)
{
CAM_Disable();
uint32_t tmpVal;
/* Disable camera module */
tmpVal = BL_RD_REG(CAM_BASE, CAM_DVP2AXI_CONFIGUE);
tmpVal = BL_CLR_REG_BIT(tmpVal, CAM_REG_DVP_ENABLE);
BL_WR_REG(CAM_BASE, CAM_DVP2AXI_CONFIGUE, tmpVal);
}
/**
@ -90,19 +288,13 @@ void cam_stop(void)
*/
uint8_t cam_get_one_frame_interleave(uint8_t **pic, uint32_t *len)
{
CAM_Interleave_Frame_Info info;
arch_memset(&info, 0, sizeof(info));
CAM_Interleave_Get_Frame_Info(&info);
if (info.validFrames == 0) {
return ERROR;
if (!BL_GET_REG_BITS_VAL(BL_RD_REG(CAM_BASE, CAM_DVP_STATUS_AND_ERROR), CAM_FRAME_VALID_CNT_0)) {
return -1;
}
*pic = (uint8_t *)(info.curFrameAddr);
*len = info.curFrameBytes;
return SUCCESS;
*pic = (uint8_t *)BL_RD_REG(CAM_BASE, CAM_FRAME_START_ADDR0_0);
*len = BL_RD_REG(CAM_BASE, CAM_FRAME_BYTE_CNT0_0);
return 0;
}
uint8_t cam_get_one_frame_planar(CAM_YUV_Mode_Type yuv, uint8_t **picYY, uint32_t *lenYY, uint8_t **picUV, uint32_t *lenUV)
@ -132,118 +324,12 @@ uint8_t cam_get_one_frame_planar(CAM_YUV_Mode_Type yuv, uint8_t **picYY, uint32_
void cam_drop_one_frame_interleave(void)
{
CAM_Interleave_Pop_Frame();
/* Pop one frame */
BL_WR_REG(CAM_BASE, CAM_DVP_FRAME_FIFO_POP, 1);
}
void cam_drop_one_frame_planar(void)
{
CAM_Planar_Pop_Frame();
}
void cam_hsync_crop(uint16_t start, uint16_t end)
{
CAM_Hsync_Crop(start, end);
}
void cam_vsync_crop(uint16_t start, uint16_t end)
{
CAM_Vsync_Crop(start, end);
}
void cam_hw_mode_wrap(uint8_t enable)
{
CAM_HW_Mode_Wrap(enable);
}
void cam_isr(cam_device_t *handle)
{
}
#ifdef BSP_USING_CAM
void CAM_Int_Callback_set(CAM_INT_Type intType, intCallback_Type *cbFun)
{
/* Check the parameters */
CHECK_PARAM(IS_CAM_INT_TYPE(intType));
camIntCbfArra[intType] = cbFun;
}
void CAMERA_IRQ(void)
{
uint32_t tmpVal;
tmpVal = BL_RD_REG(CAM_BASE, CAM_DVP_STATUS_AND_ERROR);
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_NORMAL_INT_0)) {
CAM_IntClr(CAM_INT_NORMAL_0);
if (camIntCbfArra[CAM_INT_NORMAL_0] != NULL) {
/* call the callback function */
camIntCbfArra[CAM_INT_NORMAL_0]();
}
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_NORMAL_INT_1)) {
CAM_IntClr(CAM_INT_NORMAL_1);
if (camIntCbfArra[CAM_INT_NORMAL_1] != NULL) {
/* call the callback function */
camIntCbfArra[CAM_INT_NORMAL_1]();
}
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_MEM_INT_0)) {
CAM_IntClr(CAM_INT_MEMORY_OVERWRITE_0);
if (camIntCbfArra[CAM_INT_MEMORY_OVERWRITE_0] != NULL) {
/* call the callback function */
camIntCbfArra[CAM_INT_MEMORY_OVERWRITE_0]();
}
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_MEM_INT_1)) {
CAM_IntClr(CAM_INT_MEMORY_OVERWRITE_1);
if (camIntCbfArra[CAM_INT_MEMORY_OVERWRITE_1] != NULL) {
/* call the callback function */
camIntCbfArra[CAM_INT_MEMORY_OVERWRITE_1]();
}
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_FRAME_INT_0)) {
CAM_IntClr(CAM_INT_FRAME_OVERWRITE_0);
if (camIntCbfArra[CAM_INT_FRAME_OVERWRITE_0] != NULL) {
/* call the callback function */
camIntCbfArra[CAM_INT_FRAME_OVERWRITE_0]();
}
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_FRAME_INT_1)) {
CAM_IntClr(CAM_INT_FRAME_OVERWRITE_1);
if (camIntCbfArra[CAM_INT_FRAME_OVERWRITE_1] != NULL) {
/* call the callback function */
camIntCbfArra[CAM_INT_FRAME_OVERWRITE_1]();
}
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_FIFO_INT_0)) {
CAM_IntClr(CAM_INT_FIFO_OVERWRITE_0);
if (camIntCbfArra[CAM_INT_FIFO_OVERWRITE_0] != NULL) {
/* call the callback function */
camIntCbfArra[CAM_INT_FIFO_OVERWRITE_0]();
}
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_FIFO_INT_1)) {
CAM_IntClr(CAM_INT_FIFO_OVERWRITE_1);
if (camIntCbfArra[CAM_INT_FIFO_OVERWRITE_1] != NULL) {
/* call the callback function */
camIntCbfArra[CAM_INT_FIFO_OVERWRITE_1]();
}
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_HCNT_INT)) {
CAM_IntClr(CAM_INT_HSYNC_CNT_ERROR);
if (camIntCbfArra[CAM_INT_HSYNC_CNT_ERROR] != NULL) {
/* call the callback function */
camIntCbfArra[CAM_INT_HSYNC_CNT_ERROR]();
}
}
if (BL_IS_REG_BIT_SET(tmpVal, CAM_STS_VCNT_INT)) {
CAM_IntClr(CAM_INT_VSYNC_CNT_ERROR);
if (camIntCbfArra[CAM_INT_VSYNC_CNT_ERROR] != NULL) {
/* call the callback function */
camIntCbfArra[CAM_INT_VSYNC_CNT_ERROR]();
}
}
}
#endif
/* Pop one frame */
BL_WR_REG(CAM_BASE, CAM_DVP_FRAME_FIFO_POP, 3);
}

2
drivers/bl702_driver/hal_drv/src/hal_clock.c
View File

@ -381,7 +381,7 @@ void peripheral_clock_init(void)
#endif
#endif
#if defined(BSP_USING_CAM)
#if defined(BSP_USING_CAM0)
tmpVal |= (1 << BL_AHB_SLAVE1_CAM);
#if BSP_CAM_CLOCK_SOURCE == ROOT_CLOCK_SOURCE_PLL_96M
GLB_Set_CAM_CLK(ENABLE, GLB_CAM_CLK_DLL96M, BSP_CAM_CLOCK_DIV);

18
examples/camera/camera_interleave/main.c
View File

@ -63,9 +63,6 @@ int main(void)
cam_clk_out();
cam_hsync_crop(0, 2 * CAMERA_RESOLUTION_X);
cam_vsync_crop(0, CAMERA_RESOLUTION_Y);
if (SUCCESS != image_sensor_init(DISABLE, &camera_cfg, &mjpeg_cfg)) {
MSG("Init error!\n");
BL_CASE_FAIL;
@ -73,7 +70,15 @@ int main(void)
}
}
cam_start();
cam_frame_area_t cfg;
cfg.x0 = 0;
cfg.x1 = CAMERA_RESOLUTION_X;
cfg.y0 = 0;
cfg.y1 = CAMERA_RESOLUTION_Y;
struct device *cam0 = device_find("camera0");
device_control(cam0, DEVICE_CTRL_CAM_FRAME_CUT, &cfg);
device_control(cam0, DEVICE_CTRL_RESUME, NULL);
for (i = 0; i < 3; i++) {
while (SUCCESS != cam_get_one_frame_interleave(&picture, &length)) {
@ -82,11 +87,10 @@ int main(void)
MSG("picturestartuyvy");
UART_SendData(0, picture, length);
MSG("pictureend");
cam_drop_one_frame_interleave();
device_control(cam0, DEVICE_CTRL_CAM_FRAME_DROP, NULL);
}
cam_stop();
device_control(cam0, DEVICE_CTRL_SUSPEND, NULL);
BL_CASE_SUCCESS;
while (1) {

1
examples/camera/camera_interleave/readme.md
View File

@ -1,4 +1,3 @@
**board/bl706_avb/pinmux_config.h** 中 **PINMUX_SELECT** 选择 **PINMUX_CAMERA_LCD**
**bsp_common/image_sensor/bsp_image_sensor.c** 中**FORMAT_SEL** 选择 **RGB565**
```bash

31
examples/camera/camera_interleave_pbuf/main.c
View File

@ -99,7 +99,7 @@ void my_memcpy(void *dst, void const *src, uint32_t size)
}
}
void ATTR_TCM_SECTION CAM_Interrupt_Normal(void)
void ATTR_TCM_SECTION cam_irq_callback(struct device *dev, void *args, uint32_t size, uint32_t state)
{
if (flag_normal == 0) {
// memcpy((void *)(uint32_t)(0x42023000 + (8640 * buff_using_num)), (void *)CAMERA_WRITE_ADDR, CAMERA_FRAME_SIZE);
@ -162,7 +162,6 @@ void ATTR_TCM_SECTION CAM_Interrupt_Normal(void)
return;
}
// MSG("CAM NORMAL\r\n");
return;
}
@ -182,32 +181,34 @@ int ATTR_TCM_SECTION main(void)
}
// MSG("dma open \r\n");
cam_hw_mode_wrap(DISABLE);
//CAM_HW_Mode_Wrap(DISABLE);
cam_clk_out();
cam_hsync_crop(0, 2 * CAMERA_RESOLUTION_X);
cam_vsync_crop(0, CAMERA_RESOLUTION_Y);
CAM_IntMask(CAM_INT_ALL, MASK);
CAM_Int_Callback_set(CAM_INT_NORMAL_0, &CAM_Interrupt_Normal);
CAM_IntMask(CAM_INT_NORMAL_0, UNMASK);
CPU_Interrupt_Enable(CAM_IRQn);
if (SUCCESS != image_sensor_init(DISABLE, &camera_cfg, &mjpeg_cfg)) {
MSG("Init error!\n");
BL_CASE_FAIL;
while (1) {
}
}
// MSG("cam init!\n");
cam_start();
cam_frame_area_t cfg;
cfg.x0 = 0;
cfg.x1 = CAMERA_RESOLUTION_X;
cfg.y0 = 0;
cfg.y1 = CAMERA_RESOLUTION_Y;
struct device *cam0 = device_find("camera0");
device_control(cam0, DEVICE_CTRL_CAM_FRAME_CUT, &cfg);
device_set_callback(cam0, cam_irq_callback);
device_control(cam0, DEVICE_CTRL_SET_INT, (void *)CAM_FRAME_IT);
device_control(cam0, DEVICE_CTRL_RESUME, NULL);
while (1) {
if (buff_using_num == 18 * 3) { // close cam when 3 pic saved,480x360 = 480x20x18
cam_stop();
device_control(cam0, DEVICE_CTRL_SUSPEND, NULL);
device_write(uart0, 0, (void *)(uint32_t *)PSRAM_START_ADDR, YUV400_FRAME_SIZE * 3); // uart log send 3 pic raw data
//device_write(uart0, 0, (void *)(uint32_t *)PSRAM_START_ADDR, YUV400_FRAME_SIZE * 3); // uart log send 3 pic raw data
// MSG("\r\ntim1:%d, tim2:%d, tim3:%d, tim4:%d", tim1, tim2, tim3, tim4);
return 0;

1
examples/camera/camera_interleave_pbuf/readme.md
View File

@ -1,4 +1,3 @@
**board/bl706_avb/pinmux_config.h** 中 **PINMUX_SELECT** 选择 **PINMUX_CAMERA_LCD**
**bsp_common/image_sensor/bsp_image_sensor.c** 中**IMAGE_SENSOR_USE** 选择**IMAGE_SENSOR_GC0308** (目前暂时没有 BF2013 sensor 验证)
**bsp_common/image_sensor/bsp_image_sensor.c** 中**FORMAT_SEL** 选择 **YUYV**
**bsp_common/image_sensor/bsp_image_sensor.c** 中**CAM_MODE** 选择 **CAM_USING_INT_MODE**模式

15
examples/camera/camera_interleave_psram/main.c
View File

@ -70,9 +70,6 @@ int main(void)
cam_clk_out();
cam_hsync_crop(0, 2 * CAMERA_RESOLUTION_X);
cam_vsync_crop(0, CAMERA_RESOLUTION_Y);
if (SUCCESS != image_sensor_init(DISABLE, &camera_cfg, &mjpeg_cfg)) {
MSG("Init error!\n");
BL_CASE_FAIL;
@ -80,7 +77,15 @@ int main(void)
}
}
cam_start();
cam_frame_area_t cfg;
cfg.x0 = 0;
cfg.x1 = CAMERA_RESOLUTION_X;
cfg.y0 = 0;
cfg.y1 = CAMERA_RESOLUTION_Y;
struct device *cam0 = device_find("camera0");
device_control(cam0, DEVICE_CTRL_CAM_FRAME_CUT, &cfg);
device_control(cam0, DEVICE_CTRL_RESUME, NULL);
for (i = 0; i < 5; i++) {
while (SUCCESS != cam_get_one_frame_interleave(&picture, &length)) {
@ -93,7 +98,7 @@ int main(void)
cam_drop_one_frame_interleave();
}
cam_stop();
device_control(cam0, DEVICE_CTRL_SUSPEND, NULL);
BL_CASE_SUCCESS;
while (1) {

1
examples/camera/camera_interleave_psram/readme.md
View File

@ -1,4 +1,3 @@
**board/bl706_avb/pinmux_config.h** 中 **PINMUX_SELECT** 选择 **PINMUX_CAMERA_LCD**
**bsp_common/image_sensor/bsp_image_sensor.c** 中**FORMAT_SEL** 选择 **RGB565**
```bash

20
examples/camera/camera_lcd/main.c
View File

@ -246,17 +246,21 @@ int main(void)
cam_clk_out();
cam_hsync_crop(400, (2 * CAMERA_RESOLUTION_X) + 400);
cam_vsync_crop(80, CAMERA_RESOLUTION_Y + 80);
if (SUCCESS != image_sensor_init(DISABLE, &camera_cfg, &mjpeg_cfg)) {
MSG("Init error!\n");
BL_CASE_FAIL;
while (1) {
}
}
cam_frame_area_t cfg;
cfg.x0 = 200;
cfg.x1 = CAMERA_RESOLUTION_X + 200;
cfg.y0 = 80;
cfg.y1 = CAMERA_RESOLUTION_Y + 80;
cam_start();
struct device *cam0 = device_find("camera0");
device_control(cam0, DEVICE_CTRL_CAM_FRAME_CUT, &cfg);
device_control(cam0, DEVICE_CTRL_RESUME, NULL);
LCD_Set_Addr(0, 0, CAMERA_RESOLUTION_X, CAMERA_RESOLUTION_Y);
@ -268,16 +272,16 @@ int main(void)
while (SUCCESS != cam_get_one_frame_interleave(&picture, &length)) {
}
cam_stop();
device_control(cam0, DEVICE_CTRL_SUSPEND, NULL);
#ifdef USE_YUV422
yuv422sp_to_rgb24(picture, rgb_pic, CAMERA_RESOLUTION_X, CAMERA_RESOLUTION_Y);
rgb24_to_rgb565(rgb_pic, rgb16_pic);
LCD_DrawPicture_cam(0, 0, CAMERA_RESOLUTION_X, CAMERA_RESOLUTION_Y, picture);
#else
LCD_WR_SPI_DMA(picture, (CAMERA_FRAME_SIZE));
LCD_WR_SPI_DMA((uint16_t *)picture, (CAMERA_FRAME_SIZE));
#endif
cam_drop_one_frame_interleave();
cam_start();
device_control(cam0, DEVICE_CTRL_CAM_FRAME_DROP, NULL);
device_control(cam0, DEVICE_CTRL_RESUME, NULL);
#ifdef TEST_TIM
timer_end = bflb_platform_get_time_ms();

1
examples/camera/camera_lcd/readme.md
View File

@ -1,4 +1,3 @@
**board/bl706_avb/pinmux_config.h** 中 **PINMUX_SELECT** 选择 **PINMUX_CAMERA_LCD**
**bsp_common/image_sensor/bsp_image_sensor.c** 中**FORMAT_SEL** 选择 **RGB565**
```bash

6
examples/usb/usb_video/main.c
View File

@ -353,16 +353,18 @@ uint32_t jpeg_count = 0;
void usbd_video_set_interface_callback(uint8_t value)
{
struct device* cam0 = device_find("camera0");
if (value) {
play_status = 1;
MSG("OPEN\r\n");
mjpeg_start();
cam_start();
device_control(cam0, DEVICE_CTRL_RESUME, NULL);
} else {
play_status = 0;
MSG("CLOSE\r\n");
cam_stop();
device_control(cam0, DEVICE_CTRL_SUSPEND, NULL);
mjpeg_stop();
}
}