libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
rt-thread/bsp/stm32/stm32h750-fk750m1-vbt6/board/port/camera/drv_dcmi.c

458 lines
18 KiB
C
Raw Normal View History

[bsp][stm32] add stm32h750-fk750m1-vbt6 bsp
2023-03-25 19:28:21 +08:00
/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2023-03-24 spaceman the first version
*/
#include "board.h"
#include "drv_dcmi.h"
#ifdef BSP_USING_DCMI
#define DRV_DEBUG
#define LOG_TAG "drv.dcmi"
#include <drv_log.h>
static struct stm32_dcmi rt_dcmi_dev = {0};
static volatile uint8_t ov2640_fps; // 帧率
static void rt_hw_dmci_dma_init(struct stm32_dcmi *dcmi_dev)
{
RT_ASSERT(dcmi_dev != RT_NULL);
DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
DMA_HandleTypeDef *_dma_handle = &dcmi_dev->dma_handle;
RT_ASSERT(_dcmi_handle != RT_NULL);
RT_ASSERT(_dma_handle != RT_NULL);
__HAL_RCC_DMA2_CLK_ENABLE(); // 使能DMA2时钟
_dma_handle->Instance = DMA2_Stream7; // DMA2数据流7
_dma_handle->Init.Request = DMA_REQUEST_DCMI; // DMA请求来自DCMI
_dma_handle->Init.Direction = DMA_PERIPH_TO_MEMORY; // 外设到存储器模式
_dma_handle->Init.PeriphInc = DMA_PINC_DISABLE; // 外设地址禁止自增
_dma_handle->Init.MemInc = DMA_MINC_ENABLE; // 存储器地址自增
_dma_handle->Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; // DCMI数据位宽，32位
_dma_handle->Init.MemDataAlignment = DMA_MDATAALIGN_WORD; // 存储器数据位宽，32位
_dma_handle->Init.Mode = DMA_CIRCULAR; // 循环模式
_dma_handle->Init.Priority = DMA_PRIORITY_LOW; // 优先级低
_dma_handle->Init.FIFOMode = DMA_FIFOMODE_ENABLE; // 使能fifo
_dma_handle->Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; // 全fifo模式，4*32bit大小
_dma_handle->Init.MemBurst = DMA_MBURST_SINGLE; // 单次传输
_dma_handle->Init.PeriphBurst = DMA_PBURST_SINGLE; // 单次传输
if (HAL_DMA_Init(_dma_handle) != HAL_OK) {
Error_Handler();
}
HAL_DMA_Init(_dma_handle); // 配置DMA
__HAL_LINKDMA(_dcmi_handle, DMA_Handle, *_dma_handle); // 关联DCMI句柄
HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 0, 0); // 设置中断优先级
HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn); // 使能中断
}
static rt_err_t rt_hw_dcmi_init(struct stm32_dcmi *dcmi_dev)
{
RT_ASSERT(dcmi_dev != RT_NULL);
DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
RT_ASSERT(_dcmi_handle != RT_NULL);
_dcmi_handle->Instance = DCMI;
_dcmi_handle->Init.SynchroMode = DCMI_SYNCHRO_HARDWARE; // 硬件同步模式，即使用外部的VS、HS信号进行同步
_dcmi_handle->Init.PCKPolarity = DCMI_PCKPOLARITY_RISING; // 像素时钟上升沿有效
_dcmi_handle->Init.VSPolarity = DCMI_VSPOLARITY_LOW; // VS低电平有效
_dcmi_handle->Init.HSPolarity = DCMI_HSPOLARITY_LOW; // HS低电平有效
_dcmi_handle->Init.CaptureRate = DCMI_CR_ALL_FRAME; // 捕获等级，设置每一帧都进行捕获
_dcmi_handle->Init.ExtendedDataMode = DCMI_EXTEND_DATA_8B; // 8位数据模式
_dcmi_handle->Init.JPEGMode = DCMI_JPEG_DISABLE; // 禁止JPEG模式
_dcmi_handle->Init.ByteSelectMode = DCMI_BSM_ALL; // DCMI接口捕捉所有数据
_dcmi_handle->Init.ByteSelectStart = DCMI_OEBS_ODD; // 选择开始字节，从 帧/行 的第一个数据开始捕获
_dcmi_handle->Init.LineSelectMode = DCMI_LSM_ALL; // 捕获所有行
_dcmi_handle->Init.LineSelectStart = DCMI_OELS_ODD; // 选择开始行,在帧开始后捕获第一行
if (HAL_DCMI_Init(_dcmi_handle) != HAL_OK) {
LOG_E("dcmi init error!");
return -RT_ERROR;
}
HAL_NVIC_SetPriority(DCMI_IRQn, 0, 5); // 设置中断优先级
HAL_NVIC_EnableIRQ(DCMI_IRQn); // 开启DCMI中断
DCMI->IER = 0x0;
// 在JPG模式下，一定要单独使能该中断
__HAL_DCMI_ENABLE_IT(_dcmi_handle, DCMI_IT_FRAME);
__HAL_DCMI_ENABLE(_dcmi_handle);
rt_hw_dmci_dma_init(dcmi_dev);
return RT_EOK;
}
/***************************************************************************************************************************************
* 函 数 名: ov2640_dcmi_crop
*
* 入口参数: displey_xsize 、displey_ysize - 显示器的长宽
* sensor_xsize、sensor_ysize - 摄像头传感器输出图像的长宽
*
* 函数功能: 使用DCMI的裁剪功能，将传感器输出的图像裁剪成适应屏幕的大小
*
* 说 明: 1. 因为摄像头输出的画面比例固定为4:3，不一定匹配显示器
* 2. 需要注意的是，摄像头输出的图像长、宽必须要能被4整除！（ 使用OV2640_Set_Framesize函数进行设置 ）
* 3. DCMI的水平有效像素也必须要能被4整除！
* 4. 函数会计算水平和垂直偏移，尽量让画面居中裁剪
*****************************************************************************************************************************************/
static rt_err_t ov2640_dcmi_crop(struct stm32_dcmi *dcmi_dev, uint16_t displey_xsize, uint16_t displey_ysize, uint16_t sensor_xsize, uint16_t sensor_ysize)
{
RT_ASSERT(dcmi_dev != RT_NULL);
DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
RT_ASSERT(_dcmi_handle != RT_NULL);
uint16_t dcmi_x_offset, dcmi_y_offset; // 水平和垂直偏移，垂直代表的是行数，水平代表的是像素时钟数（pclk周期数）
uint16_t dcmi_capcnt; // 水平有效像素，代表的是像素时钟数（pclk周期数）
uint16_t dcmi_vline; // 垂直有效行数
if ((displey_xsize >= sensor_xsize) || (displey_ysize >= sensor_ysize)) {
LOG_E("actual displayed size (%d, %d) >= camera output size (%d, %d), exit dcmi cropping", displey_xsize, displey_ysize, sensor_xsize, sensor_ysize);
return -RT_ERROR; // 如果实际显示的尺寸大于或等于摄像头输出的尺寸，则退出当前函数，不进行裁剪
}
// 在设置为rgb565格式时，水平偏移，必须是奇数，否则画面色彩不正确，
// 因为一个有效像素是2个字节，需要2个pclk周期，所以必须从奇数位开始，不然数据会错乱，
// 需要注意的是，寄存器值是从0开始算起的 ！
dcmi_x_offset = sensor_xsize - displey_xsize; // 实际计算过程为（sensor_xsize - lcd_xsize）/2*2
// 计算垂直偏移，尽量让画面居中裁剪，该值代表的是行数，
dcmi_y_offset = (sensor_ysize - displey_ysize) / 2 - 1; // 寄存器值是从0开始算起的，所以要-1
// 因为一个有效像素是2个字节，需要2个pclk周期，所以要乘2
// 最终得到的寄存器值，必须要能被4整除！
dcmi_capcnt = displey_xsize * 2 - 1; // 寄存器值是从0开始算起的，所以要-1
dcmi_vline = displey_ysize - 1; // 垂直有效行数
// LOG_D("%d %d %d %d", dcmi_x_offset, dcmi_y_offset, dcmi_capcnt, dcmi_vline);
HAL_DCMI_ConfigCrop(_dcmi_handle, dcmi_x_offset, dcmi_y_offset, dcmi_capcnt, dcmi_vline); // 设置裁剪窗口
HAL_DCMI_EnableCrop(_dcmi_handle); // 使能裁剪
return RT_EOK;
}
/***************************************************************************************************************************************
* 函 数 名: ov2640_dma_transmit_continuous
*
* 入口参数: dma_buffer - DMA将要传输的地址，即用于存储摄像头数据的存储区地址
* dma_buffersize - 传输的数据大小，32位宽
*
* 函数功能: 启动DMA传输，连续模式
*
* 说 明: 1. 开启连续模式之后，会一直进行传输，除非挂起或者停止DCMI
* 2. OV2640使用RGB565模式时，1个像素点需要2个字节来存储
* 3. 因为DMA配置传输数据为32位宽，计算 dma_buffersize 时，需要除以4，例如：
* 要获取 240*240分辨率 的图像，需要传输 240*240*2 = 115200 字节的数据，
* 则 dma_buffersize = 115200 / 4 = 28800 。
*
*****************************************************************************************************************************************/
static void ov2640_dma_transmit_continuous(struct stm32_dcmi *dcmi_dev, uint32_t dma_buffer, uint32_t dma_buffersize)
{
RT_ASSERT(dcmi_dev != RT_NULL);
DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
DMA_HandleTypeDef *_dma_handle = &dcmi_dev->dma_handle;
RT_ASSERT(_dcmi_handle != RT_NULL);
RT_ASSERT(_dma_handle != RT_NULL);
_dma_handle->Init.Mode = DMA_CIRCULAR; // 循环模式
HAL_DMA_Init(_dma_handle); // 配置DMA
// 使能DCMI采集数据,连续采集模式
HAL_DCMI_Start_DMA(_dcmi_handle, DCMI_MODE_CONTINUOUS, (uint32_t)dma_buffer, dma_buffersize);
}
/***************************************************************************************************************************************
* 函 数 名: ov2640_dma_transmit_snapshot
*
* 入口参数: dma_buffer - DMA将要传输的地址，即用于存储摄像头数据的存储区地址
* dma_buffersize - 传输的数据大小，32位宽
*
* 函数功能: 启动DMA传输，快照模式，传输一帧图像后停止
*
* 说 明: 1. 快照模式，只传输一帧的数据
* 2. OV2640使用RGB565模式时，1个像素点需要2个字节来存储
* 3. 因为DMA配置传输数据为32位宽，计算 dma_buffersize 时，需要除以4，例如：
* 要获取 240*240分辨率 的图像，需要传输 240*240*2 = 115200 字节的数据，
* 则 dma_buffersize = 115200 / 4 = 28800 。
* 4. 使用该模式传输完成之后，DCMI会被挂起，再次启用传输之前，需要调用 OV2640_DCMI_Resume() 恢复DCMI
*
*****************************************************************************************************************************************/
static void ov2640_dma_transmit_snapshot(struct stm32_dcmi *dcmi_dev, uint32_t dma_buffer, uint32_t dma_buffersize)
{
RT_ASSERT(dcmi_dev != RT_NULL);
DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
DMA_HandleTypeDef *_dma_handle = &dcmi_dev->dma_handle;
RT_ASSERT(_dcmi_handle != RT_NULL);
RT_ASSERT(_dma_handle != RT_NULL);
_dma_handle->Init.Mode = DMA_NORMAL; // 正常模式
HAL_DMA_Init(_dma_handle); // 配置DMA
HAL_DCMI_Start_DMA(_dcmi_handle, DCMI_MODE_SNAPSHOT, (uint32_t)dma_buffer, dma_buffersize);
}
/***************************************************************************************************************************************
* 函 数 名: ov2640_dcmi_suspend
*
* 函数功能: 挂起dcmi，停止捕获数据
*
* 说 明: 1. 开启连续模式之后，再调用该函数，会停止捕获dcmi的数据
* 2. 可以调用 ov2640_dcmi_resume() 恢复dcmi
* 3. 需要注意的，挂起dcmi期间，dma是没有停止工作的
*fanke
*****************************************************************************************************************************************/
static void ov2640_dcmi_suspend(struct stm32_dcmi *dcmi_dev)
{
RT_ASSERT(dcmi_dev != RT_NULL);
DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
RT_ASSERT(_dcmi_handle != RT_NULL);
HAL_DCMI_Suspend(_dcmi_handle); // 挂起dcmi
}
/***************************************************************************************************************************************
* 函 数 名: ov2640_dcmi_resume
*
* 函数功能: 恢复dcmi，开始捕获数据
*
* 说 明: 1. 当dcmi被挂起时，可以调用该函数恢复
* 2. 使用 ov2640_dma_transmit_snapshot() 快照模式，传输完成之后，dcmi也会被挂起，再次启用传输之前，
* 需要调用本函数恢复dcmi捕获
*
*****************************************************************************************************************************************/
static void ov2640_dcmi_resume(struct stm32_dcmi *dcmi_dev)
{
RT_ASSERT(dcmi_dev != RT_NULL);
DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
RT_ASSERT(_dcmi_handle != RT_NULL);
_dcmi_handle->State = HAL_DCMI_STATE_BUSY; // 变更dcmi标志
_dcmi_handle->Instance->CR |= DCMI_CR_CAPTURE; // 开启dcmi捕获
}
/***************************************************************************************************************************************
* 函 数 名: ov2640_dcmi_stop
*
* 函数功能: 禁止dcmi的dma请求，停止dcmi捕获，禁止dcmi外设
*
*****************************************************************************************************************************************/
static void ov2640_dcmi_stop(struct stm32_dcmi *dcmi_dev)
{
RT_ASSERT(dcmi_dev != RT_NULL);
DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
RT_ASSERT(_dcmi_handle != RT_NULL);
HAL_DCMI_Stop(_dcmi_handle);
}
void DCMI_IRQHandler(void)
{
/* enter interrupt */
rt_interrupt_enter();
HAL_DCMI_IRQHandler(&rt_dcmi_dev.dcmi_handle);
/* leave interrupt */
rt_interrupt_leave();
}
void DMA2_Stream7_IRQHandler(void)
{
/* enter interrupt */
rt_interrupt_enter();
HAL_DMA_IRQHandler(&rt_dcmi_dev.dma_handle);
/* leave interrupt */
rt_interrupt_leave();
}
/* Capture a frame of the image */
void HAL_DCMI_FrameEventCallback(DCMI_HandleTypeDef *hdcmi)
{
/* enter interrupt */
rt_interrupt_enter();
static uint32_t dcmi_tick = 0; // 用于保存当前的时间计数值
static uint8_t dcmi_frame_count = 0; // 帧数计数
if (HAL_GetTick() - dcmi_tick >= 1000) // 每隔 1s 计算一次帧率
{
dcmi_tick = HAL_GetTick(); // 重新获取当前时间计数值
ov2640_fps = dcmi_frame_count; // 获得fps
dcmi_frame_count = 0; // 计数清0
}
dcmi_frame_count++; // 没进入一次中断（每次传输完一帧数据），计数值+1
rt_sem_release(&rt_dcmi_dev.cam_semaphore);
/* leave interrupt */
rt_interrupt_leave();
}
void HAL_DCMI_ErrorCallback(DCMI_HandleTypeDef *hdcmi)
{
/* enter interrupt */
rt_interrupt_enter();
if (HAL_DCMI_GetError(hdcmi) == HAL_DCMI_ERROR_OVR) {
LOG_E("FIFO overflow error");
}
LOG_E("error:0x%08x", HAL_DCMI_GetError(hdcmi));
/* leave interrupt */
rt_interrupt_leave();
}
static rt_err_t rt_dcmi_init(rt_device_t dev)
{
RT_ASSERT(dev != RT_NULL);
rt_err_t result = RT_EOK;
struct stm32_dcmi *_rt_dcmi_dev = DCMI_DEVICE(dev);
result = rt_hw_dcmi_init(_rt_dcmi_dev);
if (result != RT_EOK) {
return result;
}
return result;
}
static rt_err_t rt_dcmi_open(rt_device_t dev, rt_uint16_t oflag)
{
RT_ASSERT(dev != RT_NULL);
return RT_EOK;
}
static rt_err_t rt_dcmi_close(rt_device_t dev)
{
RT_ASSERT(dev != RT_NULL);
return RT_EOK;
}
static rt_err_t rt_dcmi_control(rt_device_t dev, int cmd, void *args)
{
RT_ASSERT(dev != RT_NULL);
struct stm32_dcmi *_rt_dcmi_dev = DCMI_DEVICE(dev);
switch (cmd) {
case DCMI_CTRL_CROP: {
RT_ASSERT(args != RT_NULL);
struct stm32_dcmi_cropsize* cropsize = (struct stm32_dcmi_cropsize*)args;
ov2640_dcmi_crop(_rt_dcmi_dev, cropsize->displey_xsize, cropsize->displey_ysize, cropsize->sensor_xsize, cropsize->sensor_ysize);
} break;
case DCMI_CTRL_TRANSMIT_CONTINUOUS: {
RT_ASSERT(args != RT_NULL);
struct stm32_dcmi_dma_transmitbuffer* transmitbuffer = (struct stm32_dcmi_dma_transmitbuffer*)args;
ov2640_dma_transmit_continuous(_rt_dcmi_dev, transmitbuffer->dma_buffer, transmitbuffer->dma_buffersize);
} break;
case DCMI_CTRL_TRANSMIT_SNAPSHOT: {
RT_ASSERT(args != RT_NULL);
struct stm32_dcmi_dma_transmitbuffer* transmitbuffer = (struct stm32_dcmi_dma_transmitbuffer*)args;
ov2640_dma_transmit_snapshot(_rt_dcmi_dev, transmitbuffer->dma_buffer, transmitbuffer->dma_buffersize);
} break;
case DCMI_CTRL_SUSPEND: {
ov2640_dcmi_suspend(_rt_dcmi_dev);
} break;
case DCMI_CTRL_RESUME: {
ov2640_dcmi_resume(_rt_dcmi_dev);
} break;
case DCMI_CTRL_STOP: {
ov2640_dcmi_stop(_rt_dcmi_dev);
} break;
case DCMI_CTRL_GET_FPS: {
*(uint8_t*)args = ov2640_fps;
} break;
default:
return -RT_EINVAL;
}
return RT_EOK;
}
static rt_ssize_t rt_dcmi_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
{
RT_ASSERT(dev != RT_NULL);
return RT_EOK;
}
static rt_ssize_t rt_dcmi_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
{
RT_ASSERT(dev != RT_NULL);
return RT_EOK;
}
#ifdef RT_USING_DEVICE_OPS
const static struct rt_device_ops dcmi_ops =
{
rt_dcmi_init,
rt_dcmi_open,
rt_dcmi_close,
rt_dcmi_read,
rt_dcmi_write,
rt_dcmi_control,
};
#endif
int dcmi_init(void)
{
int ret = 0;
rt_device_t device = &rt_dcmi_dev.parent;
/* memset rt_dcmi_dev to zero */
memset(&rt_dcmi_dev, 0x00, sizeof(rt_dcmi_dev));
/* init cam_semaphore semaphore */
ret = rt_sem_init(&rt_dcmi_dev.cam_semaphore, "cam_sem", 0, RT_IPC_FLAG_FIFO);
if (ret != RT_EOK) {
LOG_E("init semaphore failed!\n");
ret = -RT_ENOMEM;
goto __exit;
}
device->type = RT_Device_Class_Miscellaneous;
#ifdef RT_USING_DEVICE_OPS
device->ops = &dcmi_ops;
#else
device->init = rt_dcmi_init;
device->open = rt_dcmi_open;
device->close = rt_dcmi_close;
device->read = rt_dcmi_read;
device->write = rt_dcmi_write;
device->control = rt_dcmi_control;
#endif
device->user_data = RT_NULL;
ret = rt_device_register(device, "dcmi", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
if (ret != RT_EOK) {
LOG_E("dcmi registered fail!\n\r");
return -RT_ERROR;
}
LOG_I("dcmi init success!");
return RT_EOK;
__exit:
if (ret != RT_EOK) {
rt_sem_delete(&rt_dcmi_dev.cam_semaphore);
}
return ret;
}
INIT_BOARD_EXPORT(dcmi_init);
#endif /* BSP_USING_DCMI */